Contract 0xa7f78b6A0D7906685E88c19E8DAd604156CF436B

Txn Hash
Block
From
To
Value [Txn Fee]
0xfdf183915b5659473f9e8e3438c295cb859e022faa073a0a8f12c38e0a4c257d38977412021-04-16 15:28:09108 days 10 hrs ago0xf482404f0ee4bbc780199b2995a43882a8595ada IN  Contract Creation0 HT0.003740705
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
StratX2_MDEX

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at hecoinfo.com on 2021-04-16
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol";
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

library SafeMath {
    /**
     * @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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @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 sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @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) {
        // 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 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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 mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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

contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view 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 {_setupDecimals} is
     * called.
     *
     * 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 returns (uint8) {
        return _decimals;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view 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);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(
                amount,
                "ERC20: transfer amount exceeds allowance"
            )
        );
        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].add(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)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(
                subtractedValue,
                "ERC20: decreased allowance below zero"
            )
        );
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is 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);

        _balances[sender] = _balances[sender].sub(
            amount,
            "ERC20: transfer amount exceeds balance"
        );
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(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:
     *
     * - `to` 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 = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(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);

        _balances[account] = _balances[account].sub(
            amount,
            "ERC20: burn amount exceeds balance"
        );
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(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 Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     * @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 to 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 {}
}

// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/SafeERC20.sol";
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;
        // solhint-disable-next-line no-inline-assembly
        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"
        );

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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.3._
     */
    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.3._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

library SafeERC20 {
    using SafeMath for uint256;
    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'
        // solhint-disable-next-line max-line-length
        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).add(value);
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance =
            token.allowance(address(this), spender).sub(
                value,
                "SafeERC20: decreased allowance below zero"
            );
        _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
            // solhint-disable-next-line max-line-length
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/EnumerableSet.sol";
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;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            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] = toDeleteIndex + 1; // All indexes are 1-based

            // 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)
    {
        require(
            set._values.length > index,
            "EnumerableSet: index out of bounds"
        );
        return set._values[index];
    }

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

    // 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(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(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(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(uint256(_at(set._inner, index)));
    }

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

// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol";
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() internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view 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 {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

interface IPancakeswapFarm {
    function poolLength() external view returns (uint256);

    function userInfo() external view returns (uint256);

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to)
        external
        view
        returns (uint256);

    // View function to see pending CAKEs on frontend.
    function pendingCake(uint256 _pid, address _user)
        external
        view
        returns (uint256);

    // Deposit LP tokens to MasterChef for CAKE allocation.
    function deposit(uint256 _pid, uint256 _amount) external;

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) external;

    // Stake CAKE tokens to MasterChef
    function enterStaking(uint256 _amount) external;

    // Withdraw CAKE tokens from STAKING.
    function leaveStaking(uint256 _amount) external;

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) external;
}

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

    function WETH() external pure returns (address);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

interface IWBNB is IERC20 {
    function deposit() external payable;

    function withdraw(uint256 wad) external;
}

// "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/ReentrancyGuard.sol";
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Pausable.sol";
contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() internal {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!_paused, "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(_paused, "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

abstract contract StratX2 is Ownable, ReentrancyGuard, Pausable {
    // Maximises yields in pancakeswap

    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    bool public isCAKEStaking; // only for staking CAKE using pancakeswap's native CAKE staking contract.
    bool public isSameAssetDeposit;
    bool public isAutoComp; // this vault is purely for staking. eg. WBNB-AUTO staking vault.

    address public farmContractAddress; // address of farm, eg, PCS, Thugs etc.
    uint256 public pid; // pid of pool in farmContractAddress
    address public wantAddress;
    address public token0Address;
    address public token1Address;
    address public earnedAddress;
    address public uniRouterAddress; // uniswap, pancakeswap etc

    address public wbnbAddress;
    address public autoFarmAddress;
    address public AUTOAddress;
    address public govAddress; // timelock contract
    bool public onlyGov = true;

    uint256 public lastEarnBlock = 0;
    uint256 public wantLockedTotal = 0;
    uint256 public sharesTotal = 0;

    uint256 public controllerFee = 0; // 70;
    uint256 public constant controllerFeeMax = 10000; // 100 = 1%
    uint256 public constant controllerFeeUL = 300;

    uint256 public buyBackRate = 0; // 250;
    uint256 public constant buyBackRateMax = 10000; // 100 = 1%
    uint256 public constant buyBackRateUL = 800;
    address public buyBackAddress = 0x000000000000000000000000000000000000dEaD;
    address public rewardsAddress;

    uint256 public entranceFeeFactor = 9990; // < 0.1% entrance fee - goes to pool + prevents front-running
    uint256 public constant entranceFeeFactorMax = 10000;
    uint256 public constant entranceFeeFactorLL = 9950; // 0.5% is the max entrance fee settable. LL = lowerlimit

    uint256 public withdrawFeeFactor = 10000; // 0.1% withdraw fee - goes to pool
    uint256 public constant withdrawFeeFactorMax = 10000;
    uint256 public constant withdrawFeeFactorLL = 9950; // 0.5% is the max entrance fee settable. LL = lowerlimit

    uint256 public slippageFactor = 950; // 5% default slippage tolerance
    uint256 public constant slippageFactorUL = 995;

    address[] public earnedToAUTOPath;
    address[] public earnedToToken0Path;
    address[] public earnedToToken1Path;
    address[] public token0ToEarnedPath;
    address[] public token1ToEarnedPath;

    event SetSettings(
        uint256 _entranceFeeFactor,
        uint256 _withdrawFeeFactor,
        uint256 _controllerFee,
        uint256 _buyBackRate,
        uint256 _slippageFactor
    );

    event SetGov(address _govAddress);
    event SetOnlyGov(bool _onlyGov);
    event SetUniRouterAddress(address _uniRouterAddress);
    event SetBuyBackAddress(address _buyBackAddress);
    event SetRewardsAddress(address _rewardsAddress);

    modifier onlyAllowGov() {
        require(msg.sender == govAddress, "!gov");
        _;
    }

    // Receives new deposits from user
    function deposit(address _userAddress, uint256 _wantAmt)
        public
        virtual
        onlyOwner
        nonReentrant
        whenNotPaused
        returns (uint256)
    {
        IERC20(wantAddress).safeTransferFrom(
            address(msg.sender),
            address(this),
            _wantAmt
        );

        uint256 sharesAdded = _wantAmt;
        if (wantLockedTotal > 0 && sharesTotal > 0) {
            sharesAdded = _wantAmt
                .mul(sharesTotal)
                .mul(entranceFeeFactor)
                .div(wantLockedTotal)
                .div(entranceFeeFactorMax);
        }
        sharesTotal = sharesTotal.add(sharesAdded);

        if (isAutoComp) {
            _farm();
        } else {
            wantLockedTotal = wantLockedTotal.add(_wantAmt);
        }

        return sharesAdded;
    }

    function farm() public virtual nonReentrant {
        _farm();
    }

    function _farm() internal virtual {
        require(isAutoComp, "!isAutoComp");
        uint256 wantAmt = IERC20(wantAddress).balanceOf(address(this));
        wantLockedTotal = wantLockedTotal.add(wantAmt);
        IERC20(wantAddress).safeIncreaseAllowance(farmContractAddress, wantAmt);

        if (isCAKEStaking) {
            IPancakeswapFarm(farmContractAddress).enterStaking(wantAmt); // Just for CAKE staking, we dont use deposit()
        } else {
            IPancakeswapFarm(farmContractAddress).deposit(pid, wantAmt);
        }
    }

    function _unfarm(uint256 _wantAmt) internal virtual {
        if (isCAKEStaking) {
            IPancakeswapFarm(farmContractAddress).leaveStaking(_wantAmt); // Just for CAKE staking, we dont use withdraw()
        } else {
            IPancakeswapFarm(farmContractAddress).withdraw(pid, _wantAmt);
        }
    }

    function withdraw(address _userAddress, uint256 _wantAmt)
        public
        virtual
        onlyOwner
        nonReentrant
        returns (uint256)
    {
        require(_wantAmt > 0, "_wantAmt <= 0");

        uint256 sharesRemoved = _wantAmt.mul(sharesTotal).div(wantLockedTotal);
        if (sharesRemoved > sharesTotal) {
            sharesRemoved = sharesTotal;
        }
        sharesTotal = sharesTotal.sub(sharesRemoved);

        if (withdrawFeeFactor < withdrawFeeFactorMax) {
            _wantAmt = _wantAmt.mul(withdrawFeeFactor).div(
                withdrawFeeFactorMax
            );
        }

        if (isAutoComp) {
            _unfarm(_wantAmt);
        }

        uint256 wantAmt = IERC20(wantAddress).balanceOf(address(this));
        if (_wantAmt > wantAmt) {
            _wantAmt = wantAmt;
        }

        if (wantLockedTotal < _wantAmt) {
            _wantAmt = wantLockedTotal;
        }

        wantLockedTotal = wantLockedTotal.sub(_wantAmt);

        IERC20(wantAddress).safeTransfer(autoFarmAddress, _wantAmt);

        return sharesRemoved;
    }

    // 1. Harvest farm tokens
    // 2. Converts farm tokens into want tokens
    // 3. Deposits want tokens

    function earn() public virtual nonReentrant whenNotPaused {
        require(isAutoComp, "!isAutoComp");
        if (onlyGov) {
            require(msg.sender == govAddress, "!gov");
        }

        // Harvest farm tokens
        _unfarm(0);

        if (earnedAddress == wbnbAddress) {
            _wrapBNB();
        }

        // Converts farm tokens into want tokens
        uint256 earnedAmt = IERC20(earnedAddress).balanceOf(address(this));

        earnedAmt = distributeFees(earnedAmt);
        earnedAmt = buyBack(earnedAmt);

        if (isCAKEStaking || isSameAssetDeposit) {
            lastEarnBlock = block.number;
            _farm();
            return;
        }

        IERC20(earnedAddress).safeApprove(uniRouterAddress, 0);
        IERC20(earnedAddress).safeIncreaseAllowance(
            uniRouterAddress,
            earnedAmt
        );

        if (earnedAddress != token0Address) {
            // Swap half earned to token0
            _safeSwap(
                uniRouterAddress,
                earnedAmt.div(2),
                slippageFactor,
                earnedToToken0Path,
                address(this),
                block.timestamp.add(600)
            );
        }

        if (earnedAddress != token1Address) {
            // Swap half earned to token1
            _safeSwap(
                uniRouterAddress,
                earnedAmt.div(2),
                slippageFactor,
                earnedToToken1Path,
                address(this),
                block.timestamp.add(600)
            );
        }

        // Get want tokens, ie. add liquidity
        uint256 token0Amt = IERC20(token0Address).balanceOf(address(this));
        uint256 token1Amt = IERC20(token1Address).balanceOf(address(this));
        if (token0Amt > 0 && token1Amt > 0) {
            IERC20(token0Address).safeIncreaseAllowance(
                uniRouterAddress,
                token0Amt
            );
            IERC20(token1Address).safeIncreaseAllowance(
                uniRouterAddress,
                token1Amt
            );
            IPancakeRouter02(uniRouterAddress).addLiquidity(
                token0Address,
                token1Address,
                token0Amt,
                token1Amt,
                0,
                0,
                address(this),
                block.timestamp.add(600)
            );
        }

        lastEarnBlock = block.number;

        _farm();
    }

    function buyBack(uint256 _earnedAmt) internal virtual returns (uint256) {
        if (buyBackRate <= 0) {
            return _earnedAmt;
        }

        uint256 buyBackAmt = _earnedAmt.mul(buyBackRate).div(buyBackRateMax);

        if (earnedAddress == AUTOAddress) {
            IERC20(earnedAddress).safeTransfer(buyBackAddress, buyBackAmt);
        } else {
            IERC20(earnedAddress).safeIncreaseAllowance(
                uniRouterAddress,
                buyBackAmt
            );

            _safeSwap(
                uniRouterAddress,
                buyBackAmt,
                slippageFactor,
                earnedToAUTOPath,
                buyBackAddress,
                block.timestamp.add(600)
            );
        }

        return _earnedAmt.sub(buyBackAmt);
    }

    function distributeFees(uint256 _earnedAmt)
        internal
        virtual
        returns (uint256)
    {
        if (_earnedAmt > 0) {
            // Performance fee
            if (controllerFee > 0) {
                uint256 fee =
                    _earnedAmt.mul(controllerFee).div(controllerFeeMax);
                IERC20(earnedAddress).safeTransfer(rewardsAddress, fee);
                _earnedAmt = _earnedAmt.sub(fee);
            }
        }

        return _earnedAmt;
    }

    function convertDustToEarned() public virtual whenNotPaused {
        require(isAutoComp, "!isAutoComp");
        require(!isCAKEStaking, "isCAKEStaking");

        // Converts dust tokens into earned tokens, which will be reinvested on the next earn().

        // Converts token0 dust (if any) to earned tokens
        uint256 token0Amt = IERC20(token0Address).balanceOf(address(this));
        if (token0Address != earnedAddress && token0Amt > 0) {
            IERC20(token0Address).safeIncreaseAllowance(
                uniRouterAddress,
                token0Amt
            );

            // Swap all dust tokens to earned tokens
            _safeSwap(
                uniRouterAddress,
                token0Amt,
                slippageFactor,
                token0ToEarnedPath,
                address(this),
                block.timestamp.add(600)
            );
        }

        // Converts token1 dust (if any) to earned tokens
        uint256 token1Amt = IERC20(token1Address).balanceOf(address(this));
        if (token1Address != earnedAddress && token1Amt > 0) {
            IERC20(token1Address).safeIncreaseAllowance(
                uniRouterAddress,
                token1Amt
            );

            // Swap all dust tokens to earned tokens
            _safeSwap(
                uniRouterAddress,
                token1Amt,
                slippageFactor,
                token1ToEarnedPath,
                address(this),
                block.timestamp.add(600)
            );
        }
    }

    function pause() public virtual onlyAllowGov {
        _pause();
    }

    function unpause() public virtual onlyAllowGov {
        _unpause();
    }

    function setSettings(
        uint256 _entranceFeeFactor,
        uint256 _withdrawFeeFactor,
        uint256 _controllerFee,
        uint256 _buyBackRate,
        uint256 _slippageFactor
    ) public virtual onlyAllowGov {
        require(
            _entranceFeeFactor >= entranceFeeFactorLL,
            "_entranceFeeFactor too low"
        );
        require(
            _entranceFeeFactor <= entranceFeeFactorMax,
            "_entranceFeeFactor too high"
        );
        entranceFeeFactor = _entranceFeeFactor;

        require(
            _withdrawFeeFactor >= withdrawFeeFactorLL,
            "_withdrawFeeFactor too low"
        );
        require(
            _withdrawFeeFactor <= withdrawFeeFactorMax,
            "_withdrawFeeFactor too high"
        );
        withdrawFeeFactor = _withdrawFeeFactor;

        require(_controllerFee <= controllerFeeUL, "_controllerFee too high");
        controllerFee = _controllerFee;

        require(_buyBackRate <= buyBackRateUL, "_buyBackRate too high");
        buyBackRate = _buyBackRate;

        require(
            _slippageFactor <= slippageFactorUL,
            "_slippageFactor too high"
        );
        slippageFactor = _slippageFactor;

        emit SetSettings(
            _entranceFeeFactor,
            _withdrawFeeFactor,
            _controllerFee,
            _buyBackRate,
            _slippageFactor
        );
    }

    function setGov(address _govAddress) public virtual onlyAllowGov {
        govAddress = _govAddress;
        emit SetGov(_govAddress);
    }

    function setOnlyGov(bool _onlyGov) public virtual onlyAllowGov {
        onlyGov = _onlyGov;
        emit SetOnlyGov(_onlyGov);
    }

    function setUniRouterAddress(address _uniRouterAddress)
        public
        virtual
        onlyAllowGov
    {
        uniRouterAddress = _uniRouterAddress;
        emit SetUniRouterAddress(_uniRouterAddress);
    }

    function setBuyBackAddress(address _buyBackAddress)
        public
        virtual
        onlyAllowGov
    {
        buyBackAddress = _buyBackAddress;
        emit SetBuyBackAddress(_buyBackAddress);
    }

    function setRewardsAddress(address _rewardsAddress)
        public
        virtual
        onlyAllowGov
    {
        rewardsAddress = _rewardsAddress;
        emit SetRewardsAddress(_rewardsAddress);
    }

    function inCaseTokensGetStuck(
        address _token,
        uint256 _amount,
        address _to
    ) public virtual onlyAllowGov {
        require(_token != earnedAddress, "!safe");
        require(_token != wantAddress, "!safe");
        IERC20(_token).safeTransfer(_to, _amount);
    }

    function _wrapBNB() internal virtual {
        // BNB -> WBNB
        uint256 bnbBal = address(this).balance;
        if (bnbBal > 0) {
            IWBNB(wbnbAddress).deposit{value: bnbBal}(); // BNB -> WBNB
        }
    }

    function wrapBNB() public virtual onlyAllowGov {
        _wrapBNB();
    }

    function _safeSwap(
        address _uniRouterAddress,
        uint256 _amountIn,
        uint256 _slippageFactor,
        address[] memory _path,
        address _to,
        uint256 _deadline
    ) internal virtual {
        uint256[] memory amounts =
            IPancakeRouter02(_uniRouterAddress).getAmountsOut(_amountIn, _path);
        uint256 amountOut = amounts[amounts.length.sub(1)];

        IPancakeRouter02(_uniRouterAddress)
            .swapExactTokensForTokensSupportingFeeOnTransferTokens(
            _amountIn,
            amountOut.mul(_slippageFactor).div(1000),
            _path,
            _to,
            _deadline
        );
    }
}


interface IMDEXSwapMining {
    function takerWithdraw() external;
}

contract StratX2_MDEX is StratX2 {
    address public MDXAddress;
    address public MDEXSwapMiningAddress;
    address[] public MDXToEarnedPath;

    constructor(
        address[] memory _addresses,
        uint256 _pid,
        bool _isCAKEStaking,
        bool _isSameAssetDeposit,
        bool _isAutoComp,
        address[] memory _earnedToAUTOPath,
        address[] memory _earnedToToken0Path,
        address[] memory _earnedToToken1Path,
        address[] memory _token0ToEarnedPath,
        address[] memory _token1ToEarnedPath,
        uint256 _controllerFee,
        uint256 _buyBackRate,
        uint256 _entranceFeeFactor,
        uint256 _withdrawFeeFactor,
        address[] memory _MDXToEarnedPath
    ) public {
        wbnbAddress = _addresses[0];
        govAddress = _addresses[1];
        autoFarmAddress = _addresses[2];
        AUTOAddress = _addresses[3];

        wantAddress = _addresses[4];
        token0Address = _addresses[5];
        token1Address = _addresses[6];
        earnedAddress = _addresses[7];

        farmContractAddress = _addresses[8];
        pid = _pid;
        isCAKEStaking = _isCAKEStaking;
        isSameAssetDeposit = _isSameAssetDeposit;
        isAutoComp = _isAutoComp;

        uniRouterAddress = _addresses[9];
        earnedToAUTOPath = _earnedToAUTOPath;
        earnedToToken0Path = _earnedToToken0Path;
        earnedToToken1Path = _earnedToToken1Path;
        token0ToEarnedPath = _token0ToEarnedPath;
        token1ToEarnedPath = _token1ToEarnedPath;

        controllerFee = _controllerFee;
        rewardsAddress = _addresses[10];
        buyBackRate = _buyBackRate;
        buyBackAddress = _addresses[11];
        entranceFeeFactor = _entranceFeeFactor;
        withdrawFeeFactor = _withdrawFeeFactor;

        MDXAddress = _addresses[12];
        MDEXSwapMiningAddress = _addresses[13];
        MDXToEarnedPath = _MDXToEarnedPath;

        transferOwnership(autoFarmAddress);
    }

    // Claim trade mining rewards
    function noTimeLockFunc1() public {
        require(msg.sender == govAddress, "Not authorised");
        IMDEXSwapMining(MDEXSwapMiningAddress).takerWithdraw();
        _convertMDXToEarned();
    }

    function _convertMDXToEarned() internal {
        // Converts MDX (if any) to earned tokens
        uint256 MDXAmt = IERC20(MDXAddress).balanceOf(address(this));
        if (MDXAddress != earnedAddress && MDXAmt > 0) {
            IERC20(MDXAddress).safeIncreaseAllowance(uniRouterAddress, MDXAmt);
            // Swap all dust tokens to earned tokens
            _safeSwap(
                uniRouterAddress,
                MDXAmt,
                slippageFactor,
                MDXToEarnedPath,
                address(this),
                now.add(600)
            );
        }
    }
}

Contract ABI

[{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"},{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"bool","name":"_isCAKEStaking","type":"bool"},{"internalType":"bool","name":"_isSameAssetDeposit","type":"bool"},{"internalType":"bool","name":"_isAutoComp","type":"bool"},{"internalType":"address[]","name":"_earnedToAUTOPath","type":"address[]"},{"internalType":"address[]","name":"_earnedToToken0Path","type":"address[]"},{"internalType":"address[]","name":"_earnedToToken1Path","type":"address[]"},{"internalType":"address[]","name":"_token0ToEarnedPath","type":"address[]"},{"internalType":"address[]","name":"_token1ToEarnedPath","type":"address[]"},{"internalType":"uint256","name":"_controllerFee","type":"uint256"},{"internalType":"uint256","name":"_buyBackRate","type":"uint256"},{"internalType":"uint256","name":"_entranceFeeFactor","type":"uint256"},{"internalType":"uint256","name":"_withdrawFeeFactor","type":"uint256"},{"internalType":"address[]","name":"_MDXToEarnedPath","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_buyBackAddress","type":"address"}],"name":"SetBuyBackAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_govAddress","type":"address"}],"name":"SetGov","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"_onlyGov","type":"bool"}],"name":"SetOnlyGov","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_rewardsAddress","type":"address"}],"name":"SetRewardsAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_entranceFeeFactor","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_withdrawFeeFactor","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_controllerFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_buyBackRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_slippageFactor","type":"uint256"}],"name":"SetSettings","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_uniRouterAddress","type":"address"}],"name":"SetUniRouterAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"AUTOAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MDEXSwapMiningAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MDXAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MDXToEarnedPath","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"autoFarmAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyBackAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyBackRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyBackRateMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyBackRateUL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controllerFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controllerFeeMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controllerFeeUL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"convertDustToEarned","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"},{"internalType":"uint256","name":"_wantAmt","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"earn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"earnedAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"earnedToAUTOPath","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"earnedToToken0Path","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"earnedToToken1Path","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"entranceFeeFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"entranceFeeFactorLL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"entranceFeeFactorMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"farm","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"farmContractAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"govAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_to","type":"address"}],"name":"inCaseTokensGetStuck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isAutoComp","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isCAKEStaking","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isSameAssetDeposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastEarnBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"noTimeLockFunc1","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"onlyGov","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardsAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_buyBackAddress","type":"address"}],"name":"setBuyBackAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_govAddress","type":"address"}],"name":"setGov","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_onlyGov","type":"bool"}],"name":"setOnlyGov","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardsAddress","type":"address"}],"name":"setRewardsAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_entranceFeeFactor","type":"uint256"},{"internalType":"uint256","name":"_withdrawFeeFactor","type":"uint256"},{"internalType":"uint256","name":"_controllerFee","type":"uint256"},{"internalType":"uint256","name":"_buyBackRate","type":"uint256"},{"internalType":"uint256","name":"_slippageFactor","type":"uint256"}],"name":"setSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_uniRouterAddress","type":"address"}],"name":"setUniRouterAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sharesTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"slippageFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"slippageFactorUL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token0Address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"token0ToEarnedPath","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token1Address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"token1ToEarnedPath","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniRouterAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wantAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wantLockedTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wbnbAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"},{"internalType":"uint256","name":"_wantAmt","type":"uint256"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawFeeFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawFeeFactorLL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawFeeFactorMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wrapBNB","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

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

00000000000000000000000000000000000000000000000000000000000001e0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000003c000000000000000000000000000000000000000000000000000000000000003e0000000000000000000000000000000000000000000000000000000000000046000000000000000000000000000000000000000000000000000000000000004c0000000000000000000000000000000000000000000000000000000000000054000000000000000000000000000000000000000000000000000000000000000bc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002706000000000000000000000000000000000000000000000000000000000000271000000000000000000000000000000000000000000000000000000000000005a0000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000005545153ccfca01fbd7dd11c0b23ba694d9509a6f0000000000000000000000001c2cb2f6760000ea2584d713734d46a61c8792c300000000000000000000000096a29c4bce3126266983f535b41c30dba80d5d99000000000000000000000000000000000000000000000000000000000000dead000000000000000000000000615e6285c5944540fd8bd921c9c8c56739fd1e1300000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c000000000000000000000000a71edc38d189767582c38a3145b5873052c3e47a00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c000000000000000000000000fb03e11d93632d97a8981158a632dd5986f5e909000000000000000000000000ed7d5f38c79115ca12fe6c0041abb22f0a06c3000000000000000000000000001c2cb2f6760000ea2584d713734d46a61c8792c3000000000000000000000000000000000000000000000000000000000000dead00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c0000000000000000000000007373c42502874c88954bdd6d50b53061f018422e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c000000000000000000000000a71edc38d189767582c38a3145b5873052c3e47a00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c000000000000000000000000000000000000000000000000000000000000000200000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c000000000000000000000000a71edc38d189767582c38a3145b5873052c3e47a000000000000000000000000000000000000000000000000000000000000000300000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c000000000000000000000000a71edc38d189767582c38a3145b5873052c3e47a00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000a71edc38d189767582c38a3145b5873052c3e47a00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c0000000000000000000000000000000000000000000000000000000000000000

-----Encoded View---------------
46 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000001e0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000010
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [5] : 00000000000000000000000000000000000000000000000000000000000003c0
Arg [6] : 00000000000000000000000000000000000000000000000000000000000003e0
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000460
Arg [8] : 00000000000000000000000000000000000000000000000000000000000004c0
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000540
Arg [10] : 00000000000000000000000000000000000000000000000000000000000000bc
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000002706
Arg [13] : 0000000000000000000000000000000000000000000000000000000000002710
Arg [14] : 00000000000000000000000000000000000000000000000000000000000005a0
Arg [15] : 000000000000000000000000000000000000000000000000000000000000000e
Arg [16] : 0000000000000000000000005545153ccfca01fbd7dd11c0b23ba694d9509a6f
Arg [17] : 0000000000000000000000001c2cb2f6760000ea2584d713734d46a61c8792c3
Arg [18] : 00000000000000000000000096a29c4bce3126266983f535b41c30dba80d5d99
Arg [19] : 000000000000000000000000000000000000000000000000000000000000dead
Arg [20] : 000000000000000000000000615e6285c5944540fd8bd921c9c8c56739fd1e13
Arg [21] : 00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c
Arg [22] : 000000000000000000000000a71edc38d189767582c38a3145b5873052c3e47a
Arg [23] : 00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c
Arg [24] : 000000000000000000000000fb03e11d93632d97a8981158a632dd5986f5e909
Arg [25] : 000000000000000000000000ed7d5f38c79115ca12fe6c0041abb22f0a06c300
Arg [26] : 0000000000000000000000001c2cb2f6760000ea2584d713734d46a61c8792c3
Arg [27] : 000000000000000000000000000000000000000000000000000000000000dead
Arg [28] : 00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c
Arg [29] : 0000000000000000000000007373c42502874c88954bdd6d50b53061f018422e
Arg [30] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [31] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [32] : 00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c
Arg [33] : 000000000000000000000000a71edc38d189767582c38a3145b5873052c3e47a
Arg [34] : 00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c
Arg [35] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [36] : 00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c
Arg [37] : 000000000000000000000000a71edc38d189767582c38a3145b5873052c3e47a
Arg [38] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [39] : 00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c
Arg [40] : 000000000000000000000000a71edc38d189767582c38a3145b5873052c3e47a
Arg [41] : 00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c
Arg [42] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [43] : 000000000000000000000000a71edc38d189767582c38a3145b5873052c3e47a
Arg [44] : 00000000000000000000000025d2e80cb6b86881fd7e07dd263fb79f4abe033c
Arg [45] : 0000000000000000000000000000000000000000000000000000000000000000


Deployed ByteCode Sourcemap

68501:2866:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55339:35;;;;;;;;;;;;;;;;-1:-1:-1;55339:35:0;;:::i;:::-;;;;-1:-1:-1;;;;;55339:35:0;;;;;;;;;;;;;;68616:32;;;;;;;;;;;;;;;;-1:-1:-1;68616:32:0;;:::i;54166:45::-;;;:::i;:::-;;;;;;;;;;;;;;;;66291:136;;;;;;;;;;;;;;;;-1:-1:-1;66291:136:0;;;;:::i;:::-;;53899:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;53934:32;;;:::i;54499:39::-;;;:::i;54220:30::-;;;:::i;54099:48::-;;;:::i;53813:26::-;;;:::i;56857:70::-;;;:::i;70552:201::-;;;:::i;64603:76::-;;;:::i;53973:34::-;;;:::i;54014:30::-;;;:::i;53846:25::-;;;:::i;55981:868::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;55981:868:0;;;;;;;;:::i;51795:78::-;;;:::i;66435:225::-;;;;;;;;;;;;;;;;-1:-1:-1;66435:225:0;-1:-1:-1;;;;;66435:225:0;;:::i;55173:33::-;;;;;;;;;;;;;;;;-1:-1:-1;55173:33:0;;:::i;53743:26::-;;;:::i;67110:300::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;67110:300:0;;;;;;;;;;;;;;;;;:::i;54784:40::-;;;:::i;53675:31::-;;;:::i;41769:148::-;;;:::i;54380:74::-;;;:::i;53570:28::-;;;:::i;64523:72::-;;;:::i;53152:25::-;;;:::i;64687:1445::-;;;;;;;;;;;;;;;;-1:-1:-1;64687:1445:0;;;;;;;;;;;;;;;;;;;;;;:::i;54053:32::-;;;:::i;54926:50::-;;;:::i;66889:213::-;;;;;;;;;;;;;;;;-1:-1:-1;66889:213:0;-1:-1:-1;;;;;66889:213:0;;:::i;41127:79::-;;;:::i;68573:36::-;;;:::i;68541:25::-;;;:::i;55255:35::-;;;;;;;;;;;;;;;;-1:-1:-1;55255:35:0;;:::i;53259:30::-;;;:::i;53393:34::-;;;:::i;66668:213::-;;;;;;;;;;;;;;;;-1:-1:-1;66668:213:0;-1:-1:-1;;;;;66668:213:0;;:::i;54330:43::-;;;:::i;55118:46::-;;;:::i;55297:35::-;;;;;;;;;;;;;;;;-1:-1:-1;55297:35:0;;:::i;54461:29::-;;;:::i;62947:1568::-;;;:::i;55213:35::-;;;;;;;;;;;;;;;;-1:-1:-1;55213:35:0;;:::i;66140:143::-;;;;;;;;;;;;;;;;-1:-1:-1;66140:143:0;-1:-1:-1;;;;;66140:143:0;;:::i;59077:2518::-;;;:::i;67655:76::-;;;:::i;53605:28::-;;;:::i;53296:22::-;;;:::i;53640:28::-;;;:::i;53537:26::-;;;:::i;53474:18::-;;;:::i;42072:281::-;;;;;;;;;;;;;;;;-1:-1:-1;42072:281:0;-1:-1:-1;;;;;42072:281:0;;:::i;57826:1129::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;57826:1129:0;;;;;;;;:::i;53776:30::-;;;:::i;55043:35::-;;;:::i;55339:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;55339:35:0;;-1:-1:-1;55339:35:0;:::o;68616:32::-;;;;;;;;;;54166:45;54208:3;54166:45;:::o;66291:136::-;55894:10;;-1:-1:-1;;;;;55894:10:0;55880;:24;55872:41;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;66365:7:::1;:18:::0;;;::::1;;-1:-1:-1::0;;;66365:18:0;::::1;-1:-1:-1::0;;;;66365:18:0;;::::1;::::0;;;::::1;::::0;;;66399:20:::1;::::0;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;66291:136:::0;:::o;53899:26::-;;;-1:-1:-1;;;53899:26:0;;;;;:::o;53934:32::-;;;;:::o;54499:39::-;;;;:::o;54220:30::-;;;;:::o;54099:48::-;54142:5;54099:48;:::o;53813:26::-;;;-1:-1:-1;;;;;53813:26:0;;:::o;56857:70::-;50204:1;50809:7;;:19;;50801:63;;;;;-1:-1:-1;;;50801:63:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50801:63:0;;;;;;;;;;;;;;;50204:1;50942:7;:18;56912:7:::1;:5;:7::i;:::-;50160:1:::0;51121:22;;56857:70::o;70552:201::-;70619:10;;-1:-1:-1;;;;;70619:10:0;70605;:24;70597:51;;;;;-1:-1:-1;;;70597:51:0;;;;;;;;;;;;-1:-1:-1;;;70597:51:0;;;;;;;;;;;;;;;70675:21;;;;;;;;;-1:-1:-1;;;;;70675:21:0;-1:-1:-1;;;;;70659:52:0;;:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70724:21;:19;:21::i;:::-;70552:201::o;64603:76::-;55894:10;;-1:-1:-1;;;;;55894:10:0;55880;:24;55872:41;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;64661:10:::1;:8;:10::i;53973:34::-:0;;;;:::o;54014:30::-;;;;:::o;53846:25::-;;;-1:-1:-1;;;;;53846:25:0;;:::o;55981:868::-;56153:7;41349:12;:10;:12::i;:::-;41339:6;;-1:-1:-1;;;;;41339:6:0;;;:22;;;41331:67;;;;;-1:-1:-1;;;41331:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;41331:67:0;;;;;;;;;;;;;;;50204:1:::1;50809:7;;:19;;50801:63;;;::::0;;-1:-1:-1;;;50801:63:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;;;;;;;;;50801:63:0;;;;;;;;;;;;;::::1;;50204:1;50942:7;:18:::0;;;52113:7;::::2;;52112:8;52104:37;;;::::0;;-1:-1:-1;;;52104:37:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;52104:37:0;;;;;;;;;;;;;::::2;;56185:11:::3;::::0;56178:132:::3;::::0;-1:-1:-1;;;;;56185:11:0::3;56237:10;56271:4;56291:8:::0;56178:36:::3;:132::i;:::-;56368:15;::::0;56345:8;;56368:19;;;;:38:::3;;;56405:1;56391:11;;:15;56368:38;56364:252;;;56437:167;54655:5;56437:123;56544:15;;56437:84;56503:17;;56437:43;56468:11;;56437:8;:30;;:43;;;;:::i;:::-;:65:::0;::::3;:84::i;:::-;:106:::0;::::3;:123::i;:167::-;56423:181;;56364:252;56640:11;::::0;:28:::3;::::0;56656:11;56640:15:::3;:28::i;:::-;56626:11;:42:::0;56685:10:::3;::::0;;;::::3;;;56681:130;;;56712:7;:5;:7::i;:::-;56681:130;;;56770:15;::::0;:29:::3;::::0;56790:8;56770:19:::3;:29::i;:::-;56752:15;:47:::0;56681:130:::3;50160:1:::1;51121:22:::0;;56830:11;55981:868;-1:-1:-1;;;55981:868:0:o;51795:78::-;51858:7;;;;51795:78;:::o;66435:225::-;55894:10;;-1:-1:-1;;;;;55894:10:0;55880;:24;55872:41;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;66562:16:::1;:36:::0;;-1:-1:-1;;;;;66562:36:0;::::1;-1:-1:-1::0;;;;;;66562:36:0;;::::1;::::0;::::1;::::0;;;66614:38:::1;::::0;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;66435:225:::0;:::o;55173:33::-;;;;;;;;;;53743:26;;;-1:-1:-1;;;;;53743:26:0;;:::o;67110:300::-;55894:10;;-1:-1:-1;;;;;55894:10:0;55880;:24;55872:41;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;67277:13:::1;::::0;-1:-1:-1;;;;;67267:23:0;;::::1;67277:13:::0;::::1;67267:23;;67259:41;;;::::0;;-1:-1:-1;;;67259:41:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;67259:41:0;;;;;;;;;;;;;::::1;;67329:11;::::0;-1:-1:-1;;;;;67319:21:0;;::::1;67329:11:::0;::::1;67319:21;;67311:39;;;::::0;;-1:-1:-1;;;67311:39:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;67311:39:0;;;;;;;;;;;;;::::1;;67361:41;-1:-1:-1::0;;;;;67361:27:0;::::1;67389:3:::0;67394:7;67361:27:::1;:41::i;:::-;67110:300:::0;;;:::o;54784:40::-;;;;:::o;53675:31::-;;;-1:-1:-1;;;;;53675:31:0;;:::o;41769:148::-;41349:12;:10;:12::i;:::-;41339:6;;-1:-1:-1;;;;;41339:6:0;;;:22;;;41331:67;;;;;-1:-1:-1;;;41331:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;41331:67:0;;;;;;;;;;;;;;;41876:1:::1;41860:6:::0;;41839:40:::1;::::0;-1:-1:-1;;;;;41860:6:0;;::::1;::::0;41839:40:::1;::::0;41876:1;;41839:40:::1;41907:1;41890:19:::0;;-1:-1:-1;;;;;;41890:19:0::1;::::0;;41769:148::o;54380:74::-;;;-1:-1:-1;;;;;54380:74:0;;:::o;53570:28::-;;;-1:-1:-1;;;;;53570:28:0;;:::o;64523:72::-;55894:10;;-1:-1:-1;;;;;55894:10:0;55880;:24;55872:41;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;64579:8:::1;:6;:8::i;53152:25::-:0;;;;;;;;;:::o;64687:1445::-;55894:10;;-1:-1:-1;;;;;55894:10:0;55880;:24;55872:41;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;54713:4:::1;64948:18;:41;;64926:117;;;::::0;;-1:-1:-1;;;64926:117:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;54655:5;65076:18;:42;;65054:119;;;::::0;;-1:-1:-1;;;65054:119:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;65184:17;:38:::0;;;54972:4:::1;65257:41:::0;::::1;;65235:117;;;::::0;;-1:-1:-1;;;65235:117:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;54914:5;65385:18;:42;;65363:119;;;::::0;;-1:-1:-1;;;65363:119:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;65493:17;:38:::0;;;54208:3:::1;65552:33:::0;::::1;;65544:69;;;::::0;;-1:-1:-1;;;65544:69:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;65624:13;:30:::0;;;54370:3:::1;65675:29:::0;::::1;;65667:63;;;::::0;;-1:-1:-1;;;65667:63:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;65667:63:0;;;;;;;;;;;;;::::1;;65741:11;:26:::0;;;55161:3:::1;65802:35:::0;::::1;;65780:109;;;::::0;;-1:-1:-1;;;65780:109:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;65900:14;:32:::0;;;65950:174:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;;;;;;;;;;;;;;;;;;;::::1;::::0;;;;;;;::::1;64687:1445:::0;;;;;:::o;54053:32::-;;;;:::o;54926:50::-;54972:4;54926:50;:::o;66889:213::-;55894:10;;-1:-1:-1;;;;;55894:10:0;55880;:24;55872:41;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;67012:14:::1;:32:::0;;-1:-1:-1;;;;;67012:32:0;::::1;-1:-1:-1::0;;;;;;67012:32:0;;::::1;::::0;::::1;::::0;;;67060:34:::1;::::0;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;66889:213:::0;:::o;41127:79::-;41165:7;41192:6;-1:-1:-1;;;;;41192:6:0;41127:79;:::o;68573:36::-;;;-1:-1:-1;;;;;68573:36:0;;:::o;68541:25::-;;;-1:-1:-1;;;;;68541:25:0;;:::o;55255:35::-;;;;;;;;;;53259:30;;;;;;;;;:::o;53393:34::-;;;;;;-1:-1:-1;;;;;53393:34:0;;:::o;66668:213::-;55894:10;;-1:-1:-1;;;;;55894:10:0;55880;:24;55872:41;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;66791:14:::1;:32:::0;;-1:-1:-1;;;;;66791:32:0;::::1;-1:-1:-1::0;;;;;;66791:32:0;;::::1;::::0;::::1;::::0;;;66839:34:::1;::::0;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;66668:213:::0;:::o;54330:43::-;54370:3;54330:43;:::o;55118:46::-;55161:3;55118:46;:::o;55297:35::-;;;;;;;;;;54461:29;;;-1:-1:-1;;;;;54461:29:0;;:::o;62947:1568::-;52113:7;;;;52112:8;52104:37;;;;;-1:-1:-1;;;52104:37:0;;;;;;;;;;;;-1:-1:-1;;;52104:37:0;;;;;;;;;;;;;;;63026:10:::1;::::0;;;::::1;;;63018:34;;;::::0;;-1:-1:-1;;;63018:34:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;63018:34:0;;;;;;;;;;;;;::::1;;63072:13;::::0;::::1;::::0;::::1;;;63071:14;63063:40;;;::::0;;-1:-1:-1;;;63063:40:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;63063:40:0;;;;;;;;;;;;;::::1;;63302:13;::::0;63295:46:::1;::::0;;-1:-1:-1;;;63295:46:0;;63335:4:::1;63295:46;::::0;::::1;::::0;;;63275:17:::1;::::0;-1:-1:-1;;;;;63302:13:0::1;::::0;63295:31:::1;::::0;:46;;;;;::::1;::::0;;;;;;;;63302:13;63295:46;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;63295:46:0;63373:13:::1;::::0;63356::::1;::::0;63295:46;;-1:-1:-1;;;;;;63356:13:0;;::::1;63373::::0;::::1;63356:30;::::0;::::1;::::0;:47:::1;;;63402:1;63390:9;:13;63356:47;63352:504;;;63482:16;::::0;63427:13:::1;::::0;63420:121:::1;::::0;-1:-1:-1;;;;;63427:13:0;;::::1;::::0;63482:16:::1;63517:9:::0;63420:43:::1;:121::i;:::-;63612:232;63640:16;;;;;;;;;-1:-1:-1::0;;;;;63640:16:0::1;63675:9;63703:14;;63736:18;63612:232;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;63612:232:0::1;::::0;;;;;::::1;::::0;::::1;;::::0;;::::1;;;;;;;;;63781:4;63805:24;63825:3;63805:15;:19;;:24;;;;:::i;:::-;63612:9;:232::i;:::-;63954:13;::::0;63947:46:::1;::::0;;-1:-1:-1;;;63947:46:0;;63987:4:::1;63947:46;::::0;::::1;::::0;;;63927:17:::1;::::0;-1:-1:-1;;;;;63954:13:0::1;::::0;63947:31:::1;::::0;:46;;;;;::::1;::::0;;;;;;;;63954:13;63947:46;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;63947:46:0;64025:13:::1;::::0;64008::::1;::::0;63947:46;;-1:-1:-1;;;;;;64008:13:0;;::::1;64025::::0;::::1;64008:30;::::0;::::1;::::0;:47:::1;;;64054:1;64042:9;:13;64008:47;64004:504;;;64134:16;::::0;64079:13:::1;::::0;64072:121:::1;::::0;-1:-1:-1;;;;;64079:13:0;;::::1;::::0;64134:16:::1;64169:9:::0;64072:43:::1;:121::i;:::-;64264:232;64292:16;;;;;;;;;-1:-1:-1::0;;;;;64292:16:0::1;64327:9;64355:14;;64388:18;64264:232;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;64264:232:0::1;::::0;;;;;::::1;::::0;::::1;;::::0;;::::1;;;;;;;;64433:4;64457:24;64477:3;64457:15;:19;;:24;;;;:::i;64264:232::-;52152:1;;62947:1568::o:0;55213:35::-;;;;;;;;;;66140:143;55894:10;;-1:-1:-1;;;;;55894:10:0;55880;:24;55872:41;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;66216:10:::1;:24:::0;;-1:-1:-1;;;;;66216:24:0;::::1;-1:-1:-1::0;;;;;;66216:24:0;;::::1;::::0;::::1;::::0;;;66256:19:::1;::::0;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;66140:143:::0;:::o;59077:2518::-;50204:1;50809:7;;:19;;50801:63;;;;;-1:-1:-1;;;50801:63:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50801:63:0;;;;;;;;;;;;;;;50204:1;50942:7;:18;;;52113:7;::::1;;52112:8;52104:37;;;::::0;;-1:-1:-1;;;52104:37:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;52104:37:0;;;;;;;;;;;;;::::1;;59154:10:::2;::::0;;;::::2;;;59146:34;;;::::0;;-1:-1:-1;;;59146:34:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;59146:34:0;;;;;;;;;;;;;::::2;;59195:7;::::0;-1:-1:-1;;;59195:7:0;::::2;;;59191:81;;;59241:10;::::0;-1:-1:-1;;;;;59241:10:0::2;59227;:24;59219:41;;;::::0;;-1:-1:-1;;;59219:41:0;;::::2;;::::0;;::::2;::::0;;;;;;;;-1:-1:-1;;;59219:41:0;;;;;;;;;;;;;::::2;;59316:10;59324:1;59316:7;:10::i;:::-;59360:11;::::0;59343:13:::2;::::0;-1:-1:-1;;;;;59343:13:0;;::::2;59360:11:::0;::::2;59343:28;59339:71;;;59388:10;:8;:10::i;:::-;59499:13;::::0;59492:46:::2;::::0;;-1:-1:-1;;;59492:46:0;;59532:4:::2;59492:46;::::0;::::2;::::0;;;59472:17:::2;::::0;-1:-1:-1;;;;;59499:13:0::2;::::0;59492:31:::2;::::0;:46;;;;;::::2;::::0;;;;;;;;59499:13;59492:46;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;59492:46:0;;-1:-1:-1;59563:25:0::2;59492:46:::0;59563:14:::2;:25::i;:::-;59551:37;;59611:18;59619:9;59611:7;:18::i;:::-;59646:13;::::0;59599:30;;-1:-1:-1;59646:13:0::2;::::0;::::2;;;::::0;:35:::2;;-1:-1:-1::0;59663:18:0::2;::::0;;;::::2;;;59646:35;59642:139;;;59714:12;59698:13;:28:::0;59741:7:::2;:5;:7::i;:::-;59763;;;59642:139;59827:16;::::0;59800:13:::2;::::0;59793:54:::2;::::0;-1:-1:-1;;;;;59800:13:0;;::::2;::::0;59827:16:::2;;59793:33;:54::i;:::-;59916:16;::::0;59865:13:::2;::::0;59858:109:::2;::::0;-1:-1:-1;;;;;59865:13:0;;::::2;::::0;59916:16:::2;59947:9:::0;59858:43:::2;:109::i;:::-;60001:13;::::0;59984::::2;::::0;-1:-1:-1;;;;;59984:13:0;;::::2;60001::::0;::::2;59984:30;59980:345;;60102:16;::::0;60074:239:::2;::::0;-1:-1:-1;;;;;60102:16:0::2;60137;:9:::0;60151:1:::2;60137:13;:16::i;:::-;60172:14;;60205:18;60074:239;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;60074:239:0::2;::::0;;;;;::::2;::::0;::::2;;::::0;;::::2;;;;;;;;60250:4;60274:24;60294:3;60274:15;:19;;:24;;;;:::i;60074:239::-;60358:13;::::0;60341::::2;::::0;-1:-1:-1;;;;;60341:13:0;;::::2;60358::::0;::::2;60341:30;60337:345;;60459:16;::::0;60431:239:::2;::::0;-1:-1:-1;;;;;60459:16:0::2;60494;:9:::0;60508:1:::2;60494:13;:16::i;:::-;60529:14;;60562:18;60431:239;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;60431:239:0::2;::::0;;;;;::::2;::::0;::::2;;::::0;;::::2;;;;;;;;60607:4;60631:24;60651:3;60631:15;:19;;:24;;;;:::i;60431:239::-;60768:13;::::0;60761:46:::2;::::0;;-1:-1:-1;;;60761:46:0;;60801:4:::2;60761:46;::::0;::::2;::::0;;;60741:17:::2;::::0;-1:-1:-1;;;;;60768:13:0::2;::::0;60761:31:::2;::::0;:46;;;;;::::2;::::0;;;;;;;;60768:13;60761:46;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;60761:46:0;60845:13:::2;::::0;60838:46:::2;::::0;;-1:-1:-1;;;60838:46:0;;60878:4:::2;60838:46;::::0;::::2;::::0;;;60761;;-1:-1:-1;60818:17:0::2;::::0;-1:-1:-1;;;;;60845:13:0;;::::2;::::0;60838:31:::2;::::0;:46;;;;;60761::::2;::::0;60838;;;;;;;;60845:13;60838:46;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;60838:46:0;;-1:-1:-1;60899:13:0;;;;;:30:::2;;;60928:1;60916:9;:13;60899:30;60895:632;;;61008:16;::::0;60953:13:::2;::::0;60946:121:::2;::::0;-1:-1:-1;;;;;60953:13:0;;::::2;::::0;61008:16:::2;61043:9:::0;60946:43:::2;:121::i;:::-;61144:16;::::0;61089:13:::2;::::0;61082:121:::2;::::0;-1:-1:-1;;;;;61089:13:0;;::::2;::::0;61144:16:::2;61179:9:::0;61082:43:::2;:121::i;:::-;61235:16;::::0;61284:13:::2;::::0;61316::::2;::::0;-1:-1:-1;;;;;61235:16:0;;::::2;::::0;61218:47:::2;::::0;61284:13;::::2;::::0;61316::::2;61348:9:::0;61376;61235:16:::2;::::0;61452:4:::2;61476:24;:15;61496:3;61476:19;:24::i;:::-;61218:297;;;;;;;;;;;;;-1:-1:-1::0;;;;;61218:297:0::2;;;;;;-1:-1:-1::0;;;;;61218:297:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;61218:297:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;;60895:632:0::2;61555:12;61539:13;:28:::0;61580:7:::2;:5;:7::i;:::-;52152:1;;;50160::::0;51121:22;;59077:2518::o;67655:76::-;55894:10;;-1:-1:-1;;;;;55894:10:0;55880;:24;55872:41;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;-1:-1:-1;;;55872:41:0;;;;;;;;;;;;;;;67713:10:::1;:8;:10::i;53605:28::-:0;;;-1:-1:-1;;;;;53605:28:0;;:::o;53296:22::-;;;;;;;;;:::o;53640:28::-;;;-1:-1:-1;;;;;53640:28:0;;:::o;53537:26::-;;;-1:-1:-1;;;;;53537:26:0;;:::o;53474:18::-;;;;:::o;42072:281::-;41349:12;:10;:12::i;:::-;41339:6;;-1:-1:-1;;;;;41339:6:0;;;:22;;;41331:67;;;;;-1:-1:-1;;;41331:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;41331:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;42175:22:0;::::1;42153:110;;;;-1:-1:-1::0;;;42153:110:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42300:6;::::0;;42279:38:::1;::::0;-1:-1:-1;;;;;42279:38:0;;::::1;::::0;42300:6;::::1;::::0;42279:38:::1;::::0;::::1;42328:6;:17:::0;;-1:-1:-1;;;;;;42328:17:0::1;-1:-1:-1::0;;;;;42328:17:0;;;::::1;::::0;;;::::1;::::0;;42072:281::o;57826:1129::-;57976:7;41349:12;:10;:12::i;:::-;41339:6;;-1:-1:-1;;;;;41339:6:0;;;:22;;;41331:67;;;;;-1:-1:-1;;;41331:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;41331:67:0;;;;;;;;;;;;;;;50204:1:::1;50809:7;;:19;;50801:63;;;::::0;;-1:-1:-1;;;50801:63:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;;;;;;;;;50801:63:0;;;;;;;;;;;;;::::1;;50204:1;50942:7;:18:::0;58009:12;58001:38:::2;;;::::0;;-1:-1:-1;;;58001:38:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;58001:38:0;;;;;;;;;;;;;::::2;;58052:21;58076:46;58106:15;;58076:25;58089:11;;58076:8;:12;;:25;;;;:::i;:46::-;58052:70;;58153:11;;58137:13;:27;58133:87;;;-1:-1:-1::0;58197:11:0::2;::::0;58133:87:::2;58244:11;::::0;:30:::2;::::0;58260:13;58244:15:::2;:30::i;:::-;58230:11;:44:::0;58291:17:::2;::::0;54914:5:::2;-1:-1:-1::0;58287:173:0::2;;;58359:89;54914:5;58359:31;58372:17;;58359:8;:12;;:31;;;;:::i;:89::-;58348:100;;58287:173;58476:10;::::0;;;::::2;;;58472:60;;;58503:17;58511:8;58503:7;:17::i;:::-;58569:11;::::0;;58562:44:::2;::::0;;-1:-1:-1;;;58562:44:0;;58600:4:::2;58562:44:::0;;::::2;::::0;;;;;58544:15:::2;::::0;-1:-1:-1;;;;;58569:11:0;;::::2;::::0;58562:29:::2;::::0;:44;;;;;::::2;::::0;;;;;;;;58569:11;58562:44;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;58562:44:0;;-1:-1:-1;58621:18:0;;::::2;58617:69;;;58667:7;58656:18;;58617:69;58720:8;58702:15;;:26;58698:85;;;58756:15;;58745:26;;58698:85;58813:15;::::0;:29:::2;::::0;58833:8;58813:19:::2;:29::i;:::-;58795:15;:47:::0;58888:15:::2;::::0;58862:11:::2;::::0;58855:59:::2;::::0;-1:-1:-1;;;;;58862:11:0;;::::2;::::0;58888:15:::2;58905:8:::0;58855:32:::2;:59::i;:::-;-1:-1:-1::0;50160:1:0::1;51121:22:::0;;58934:13;57826:1129;-1:-1:-1;;;57826:1129:0:o;53776:30::-;;;-1:-1:-1;;;;;53776:30:0;;:::o;55043:35::-;;;;:::o;56935:556::-;56988:10;;;;;;;56980:34;;;;;-1:-1:-1;;;56980:34:0;;;;;;;;;;;;-1:-1:-1;;;56980:34:0;;;;;;;;;;;;;;;57050:11;;;57043:44;;;-1:-1:-1;;;57043:44:0;;57081:4;57043:44;;;;;;;;57025:15;;-1:-1:-1;;;;;57050:11:0;;;;57043:29;;:44;;;;;;;;;;;;;;57050:11;57043:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57043:44:0;57116:15;;57043:44;;-1:-1:-1;57116:28:0;;57043:44;57116:19;:28::i;:::-;57098:15;:46;57197:19;;;57162:11;57155:71;;-1:-1:-1;;;;;57162:11:0;;;;57197:19;;;;;57218:7;57155:41;:71::i;:::-;57243:13;;;;;;;57239:245;;;57290:19;;;;;;;;;-1:-1:-1;;;;;57290:19:0;-1:-1:-1;;;;;57273:50:0;;57324:7;57273:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57239:245;;;57430:19;;;;;;;;;-1:-1:-1;;;;;57430:19:0;-1:-1:-1;;;;;57413:45:0;;57459:3;;57464:7;57413:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57239:245;56935:556;:::o;70761:603::-;70887:10;;70880:43;;;-1:-1:-1;;;70880:43:0;;70917:4;70880:43;;;;;;70863:14;;-1:-1:-1;;;;;70887:10:0;;70880:28;;:43;;;;;;;;;;;;;;70887:10;70880:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70880:43:0;70952:13;;70938:10;;70880:43;;-1:-1:-1;;;;;;70938:10:0;;;70952:13;;70938:27;;;;:41;;;70978:1;70969:6;:10;70938:41;70934:423;;;71037:16;;71003:10;;70996:66;;-1:-1:-1;;;;;71003:10:0;;;;71037:16;71055:6;70996:40;:66::i;:::-;71131:214;71159:16;;;;;;;;;-1:-1:-1;;;;;71159:16:0;71194:6;71219:14;;71252:15;71131:214;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;71131:214:0;;;;;;;;;;;;;;;;;;;;71294:4;71318:12;71326:3;71318;:7;;:12;;;;:::i;52844:120::-;52389:7;;;;52381:40;;;;;-1:-1:-1;;;52381:40:0;;;;;;;;;;;;-1:-1:-1;;;52381:40:0;;;;;;;;;;;;;;;52903:7:::1;:15:::0;;-1:-1:-1;;52903:15:0::1;::::0;;52934:22:::1;52943:12;:10;:12::i;:::-;52934:22;::::0;;-1:-1:-1;;;;;52934:22:0;;::::1;::::0;;;;;;;::::1;::::0;;::::1;52844:120::o:0;209:106::-;297:10;209:106;:::o;27516:285::-;27714:68;;;-1:-1:-1;;;;;27714:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;27714:68:0;-1:-1:-1;;;27714:68:0;;;27660:133;;27694:5;;27660:19;:133::i;:::-;27516:285;;;;:::o;2214:471::-;2272:7;2517:6;2513:47;;-1:-1:-1;2547:1:0;2540:8;;2513:47;2584:5;;;2588:1;2584;:5;:1;2608:5;;;;;:10;2600:56;;;;-1:-1:-1;;;2600:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2676:1;-1:-1:-1;2214:471:0;;;;;:::o;3161:132::-;3219:7;3246:39;3250:1;3253;3246:39;;;;;;;;;;;;;;;;;:3;:39::i;826:181::-;884:7;916:5;;;940:6;;;;932:46;;;;;-1:-1:-1;;;932:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;27260:248;27431:58;;;-1:-1:-1;;;;;27431:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;27431:58:0;-1:-1:-1;;;27431:58:0;;;27377:123;;27411:5;;27377:19;:123::i;52585:118::-;52113:7;;;;52112:8;52104:37;;;;;-1:-1:-1;;;52104:37:0;;;;;;;;;;;;-1:-1:-1;;;52104:37:0;;;;;;;;;;;;;;;52645:7:::1;:14:::0;;-1:-1:-1;;52645:14:0::1;52655:4;52645:14;::::0;;52675:20:::1;52682:12;:10;:12::i;28785:436::-:0;28916:20;28952:50;28996:5;28952;-1:-1:-1;;;;;28952:15:0;;28976:4;28983:7;28952:39;;;;;;;;;;;;;-1:-1:-1;;;;;28952:39:0;;;;;;-1:-1:-1;;;;;28952:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28952:39:0;;:43;:50::i;:::-;29067:135;;;-1:-1:-1;;;;;29067:135:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;29067:135:0;-1:-1:-1;;;29067:135:0;;;28916:86;;-1:-1:-1;29013:200:0;;29047:5;;29013:19;:200::i;67739:679::-;68014:67;;;-1:-1:-1;;;68014:67:0;;;;;;;;;;;;;;;;;;;;;;67974:24;;-1:-1:-1;;;;;68014:49:0;;;;;68064:9;;68075:5;;68014:67;;;;;;;;;;;;;;-1:-1:-1;68014:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;68014:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68014:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67974:107;;68092:17;68112:7;68120:21;68139:1;68120:7;:14;:18;;:21;;;;:::i;:::-;68112:30;;;;;;;;;;;;;;68092:50;;68172:17;-1:-1:-1;;;;;68155:103:0;;68273:9;68297:40;68332:4;68297:30;68311:15;68297:9;:13;;:30;;;;:::i;:40::-;68352:5;68372:3;68390:9;68155:255;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;68155:255:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67739:679;;;;;;;;:::o;57499:319::-;57566:13;;;;;;;57562:249;;;57613:19;;;;;;;;;-1:-1:-1;;;;;57613:19:0;-1:-1:-1;;;;;57596:50:0;;57647:8;57596:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57562:249;57755:19;;;;;;;;;-1:-1:-1;;;;;57755:19:0;-1:-1:-1;;;;;57738:46:0;;57785:3;;57790:8;57738:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67418:229;67507:21;67543:10;;67539:101;;67576:11;;;;;;;;;-1:-1:-1;;;;;67576:11:0;-1:-1:-1;;;;;67570:26:0;;67604:6;67570:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67418:229;:::o;62433:506::-;62530:7;62559:14;;62555:347;;62626:13;;:17;62622:269;;62664:11;62699:51;54142:5;62699:29;62714:13;;62699:10;:14;;:29;;;;:::i;:51::-;62804:14;;62776:13;;62664:86;;-1:-1:-1;62769:55:0;;-1:-1:-1;;;;;62776:13:0;;;;62804:14;62664:86;62769:34;:55::i;:::-;62856:19;:10;62871:3;62856:14;:19::i;:::-;62843:32;;62622:269;;-1:-1:-1;62921:10:0;62433:506;;;;:::o;61603:822::-;61666:7;61705:1;61690:11;;:16;61686:66;;-1:-1:-1;61730:10:0;61723:17;;61686:66;61764:18;61785:47;54306:5;61785:27;61800:11;;61785:10;:14;;:27;;;;:::i;:47::-;61866:11;;61849:13;;61764:68;;-1:-1:-1;;;;;;61849:13:0;;;61866:11;;61849:28;61845:527;;;61929:14;;61901:13;;61894:62;;-1:-1:-1;;;;;61901:13:0;;;;61929:14;61945:10;61894:34;:62::i;:::-;61845:527;;;62051:16;;61996:13;;61989:122;;-1:-1:-1;;;;;61996:13:0;;;;62051:16;62086:10;61989:43;:122::i;:::-;62128:232;62156:16;;;;;;;;;-1:-1:-1;;;;;62156:16:0;62191:10;62220:14;;62253:16;62128:232;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;62128:232:0;;;;;;;;;;;;;;;;-1:-1:-1;;62288:14:0;;-1:-1:-1;;;;;62288:14:0;;-1:-1:-1;62321:24:0;;-1:-1:-1;62321:15:0;;-1:-1:-1;62341:3:0;62321:19;:24::i;62128:232::-;62391:26;:10;62406;62391:14;:26::i;:::-;62384:33;61603:822;-1:-1:-1;;;61603:822:0:o;28070:707::-;28488:10;;;28487:62;;-1:-1:-1;28504:39:0;;;-1:-1:-1;;;28504:39:0;;28528:4;28504:39;;;;-1:-1:-1;;;;;28504:39:0;;;;;;;;;:15;;;;;;:39;;;;;;;;;;;;;;;:15;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28504:39:0;:44;28487:62;28465:166;;;;-1:-1:-1;;;28465:166:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28696:62;;;-1:-1:-1;;;;;28696:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;28696:62:0;-1:-1:-1;;;28696:62:0;;;28642:127;;28676:5;;28642:19;:127::i;1290:136::-;1348:7;1375:43;1379:1;1382;1375:43;;;;;;;;;;;;;;;;;:3;:43::i;30150:885::-;30574:23;30613:118;30659:4;30613:118;;;;;;;;;;;;;;;;;30621:5;-1:-1:-1;;;;;30613:27:0;;;:118;;;;;:::i;:::-;30746:17;;30574:157;;-1:-1:-1;30746:21:0;30742:286;;30919:10;30908:30;;;;;;;;;;;;;;;-1:-1:-1;30908:30:0;30882:134;;;;-1:-1:-1;;;30882:134:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3789:312;3909:7;3944:12;3937:5;3929:28;;;;-1:-1:-1;;;3929:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3968:9;3984:1;3980;:5;;;;;;;3789:312;-1:-1:-1;;;;;3789:312:0:o;1729:226::-;1849:7;1885:12;1877:6;;;;1869:29;;;;-1:-1:-1;;;1869:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1921:5:0;;;1729:226::o;22256:229::-;22393:12;22425:52;22447:6;22455:4;22461:1;22464:12;22425:21;:52::i;:::-;22418:59;22256:229;-1:-1:-1;;;;22256:229:0:o;23472:621::-;23642:12;23714:5;23689:21;:30;;23667:118;;;;-1:-1:-1;;;23667:118:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23804:18;23815:6;23804:10;:18::i;:::-;23796:60;;;;;-1:-1:-1;;;23796:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;23930:12;23944:23;23984:6;-1:-1:-1;;;;;23984:11:0;24003:5;24010:4;23984:31;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;23984:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23929:86;;;;24033:52;24051:7;24060:10;24072:12;24033:17;:52::i;:::-;24026:59;23472:621;-1:-1:-1;;;;;;;23472:621:0:o;19219:444::-;19599:20;19647:8;;;19219:444::o;26384:777::-;26534:12;26563:7;26559:595;;;-1:-1:-1;26594:10:0;26587:17;;26559:595;26708:17;;:21;26704:439;;26971:10;26965:17;27032:15;27019:10;27015:2;27011:19;27004:44;26919:148;27107:20;;-1:-1:-1;;;27107:20:0;;;;;;;;;;;;;;;;;27114:12;;27107:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Swarm Source

ipfs://64261c286edbf3b8f1a6bf3fc8e495cbfde5d6cd03d3879a87b6cd0ea54594ae
Block Transaction Gas Used Reward
Age Block Fee Address Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading