Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at polygonscan.com on 2021-09-07
*/

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

// File contracts/libs/IERC20.sol

// 

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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


// File contracts/libs/IERC20Metadata.sol

// 

pragma solidity ^0.8.0;

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

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

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


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

// 

pragma solidity ^0.8.0;

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

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


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

// 

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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


// File contracts/libs/ERC20.sol

// 

pragma solidity ^0.8.0;



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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

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

        return true;
    }

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

        _beforeTokenTransfer(sender, recipient, amount);

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

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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


// File @uniswap/v2-periphery/contracts/interfaces/[email protected]

pragma solidity >=0.6.2;

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

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

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


// File @uniswap/v2-periphery/contracts/interfaces/[email protected]

pragma solidity >=0.6.2;

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

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


// File @uniswap/v2-core/contracts/interfaces/[email protected]

pragma solidity >=0.5.0;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

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

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

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

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

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

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

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

    function initialize(address, address) external;
}


// File @uniswap/v2-core/contracts/interfaces/[email protected]

pragma solidity >=0.5.0;

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}


// File contracts/libs/DarksideToolBox.sol

// 

pragma solidity ^0.8.0;




contract DarksideToolBox {

    IUniswapV2Router02 public immutable darksideSwapRouter;

    uint256 public immutable startBlock;

    /**
     * @notice Constructs the DarksideToken contract.
     */
    constructor(uint256 _startBlock, IUniswapV2Router02 _darksideSwapRouter) public {
        startBlock = _startBlock;
        darksideSwapRouter = _darksideSwapRouter;
    }

    function convertToTargetValueFromPair(IUniswapV2Pair pair, uint256 sourceTokenAmount, address targetAddress) public view returns (uint256) {
        require(pair.token0() == targetAddress || pair.token1() == targetAddress, "one of the pairs must be the targetAddress");
        if (sourceTokenAmount == 0)
            return 0;

        (uint256 res0, uint256 res1, ) = pair.getReserves();
        if (res0 == 0 || res1 == 0)
            return 0;

        if (pair.token0() == targetAddress)
            return (res0 * sourceTokenAmount) / res1;
        else
            return (res1 * sourceTokenAmount) / res0;
    }

    function getTokenUSDCValue(uint256 tokenBalance, address token, uint256 tokenType, bool viaMaticUSDC, address usdcAddress) external view returns (uint256) {
        require(tokenType == 0 || tokenType == 1, "invalid token type provided");
        if (token == address(usdcAddress))
            return tokenBalance;

        // lp type
        if (tokenType == 1) {
            IUniswapV2Pair lpToken = IUniswapV2Pair(token);
            if (lpToken.totalSupply() == 0)
                return 0;
            // If lp contains usdc, we can take a short-cut
            if (lpToken.token0() == address(usdcAddress)) {
                return (IERC20(lpToken.token0()).balanceOf(address(lpToken)) * tokenBalance * 2) / lpToken.totalSupply();
            } else if (lpToken.token1() == address(usdcAddress)){
                return (IERC20(lpToken.token1()).balanceOf(address(lpToken)) * tokenBalance * 2) / lpToken.totalSupply();
            }
        }

        // Only used for lp type tokens.
        address lpTokenAddress = token;
        // If token0 or token1 is matic, use that, else use token0.
        if (tokenType == 1) {
            token = IUniswapV2Pair(token).token0() == darksideSwapRouter.WETH() ? darksideSwapRouter.WETH() :
                        (IUniswapV2Pair(token).token1() == darksideSwapRouter.WETH() ? darksideSwapRouter.WETH() : IUniswapV2Pair(token).token0());
        }

        // if it is an LP token we work with all of the reserve in the LP address to scale down later.
        uint256 tokenAmount = (tokenType == 1) ? IERC20(token).balanceOf(lpTokenAddress) : tokenBalance;

        uint256 usdcEquivalentAmount = 0;

        if (viaMaticUSDC) {
            uint256 maticAmount = 0;

            if (token == darksideSwapRouter.WETH()) {
                maticAmount = tokenAmount;
            } else {

                // As we arent working with usdc at this point (early return), this is okay.
                IUniswapV2Pair maticPair = IUniswapV2Pair(IUniswapV2Factory(darksideSwapRouter.factory()).getPair(darksideSwapRouter.WETH(), token));

                if (address(maticPair) == address(0))
                    return 0;

                maticAmount = convertToTargetValueFromPair(maticPair, tokenAmount, darksideSwapRouter.WETH());
            }

            // As we arent working with usdc at this point (early return), this is okay.
            IUniswapV2Pair usdcmaticPair = IUniswapV2Pair(IUniswapV2Factory(darksideSwapRouter.factory()).getPair(darksideSwapRouter.WETH(), address(usdcAddress)));

            if (address(usdcmaticPair) == address(0))
                return 0;

            usdcEquivalentAmount = convertToTargetValueFromPair(usdcmaticPair, maticAmount, usdcAddress);
        } else {
            // As we arent working with usdc at this point (early return), this is okay.
            IUniswapV2Pair usdcPair = IUniswapV2Pair(IUniswapV2Factory(darksideSwapRouter.factory()).getPair(address(usdcAddress), token));

            if (address(usdcPair) == address(0))
                return 0;

            usdcEquivalentAmount = convertToTargetValueFromPair(usdcPair, tokenAmount, usdcAddress);
        }

        // for the tokenType == 1 path usdcEquivalentAmount is the USDC value of all the tokens in the parent LP contract.

        if (tokenType == 1)
            return (usdcEquivalentAmount * tokenBalance * 2) / IUniswapV2Pair(lpTokenAddress).totalSupply();
        else
            return usdcEquivalentAmount;
    }

    function getNumberOfHalvingsSinceStart(uint256 CZDiamondReleaseHalfLife, uint256 _to) public view returns (uint256) {
        if (_to <= startBlock)
            return 0;

        return (_to - startBlock) / CZDiamondReleaseHalfLife;
    }

    function getPreviousCZDiamondHalvingBlock(uint256 CZDiamondReleaseHalfLife, uint256 _block) public view  returns (uint256) {
        // won't revert from getCZDiamondRelease due to bounds check
        require(_block >= startBlock, "can't get previous CZDiamond halving before startBlock");

        uint256 numberOfHalvings = getNumberOfHalvingsSinceStart(CZDiamondReleaseHalfLife, _block);
        return numberOfHalvings * CZDiamondReleaseHalfLife + startBlock;
    }

    function getNextCZDiamondHalvingBlock(uint256 CZDiamondReleaseHalfLife, uint256 _block) public view  returns (uint256) {
        // won't revert from getCZDiamondRelease due to bounds check
        require(_block >= startBlock, "can't get previous CZDiamond halving before startBlock");

        uint256 numberOfHalvings = getNumberOfHalvingsSinceStart(CZDiamondReleaseHalfLife, _block);

        if ((_block - startBlock) % CZDiamondReleaseHalfLife == 0)
            return numberOfHalvings * CZDiamondReleaseHalfLife + startBlock;
        else
            return (numberOfHalvings + 1) * CZDiamondReleaseHalfLife + startBlock;
    }

    function getCZDiamondReleaseForBlockE24(uint256 initialCZDiamondReleaseRate, uint256 CZDiamondReleaseHalfLife, uint256 _block) public view  returns (uint256) {
        if (_block < startBlock)
            return 0;

        uint256 numberOfHalvings = getNumberOfHalvingsSinceStart(CZDiamondReleaseHalfLife, _block);
        return (initialCZDiamondReleaseRate * 1e24) / (2 ** numberOfHalvings);
    }

    // Return CZDIAMOND reward release over the given _from to _to block.
    function getCZDiamondRelease(uint256 initialCZDiamondReleaseRate, uint256 CZDiamondReleaseHalfLife, uint256 _from, uint256 _to) external view returns (uint256) {
        if (_from < startBlock || _to <= _from)
            return 0;

        uint256 releaseDuration = _to - _from;

        uint256 startReleaseE24 = getCZDiamondReleaseForBlockE24(initialCZDiamondReleaseRate, CZDiamondReleaseHalfLife, _from);
        uint256 endReleaseE24 = getCZDiamondReleaseForBlockE24(initialCZDiamondReleaseRate, CZDiamondReleaseHalfLife, _to);

        // If we are all in the same era its a rectangle problem
        if (startReleaseE24 == endReleaseE24)
            return (endReleaseE24 * releaseDuration) / 1e24;

        // The idea here is that if we span multiple halving eras, we can use triangle geometry to take an average.
        uint256 startSkipBlock = getNextCZDiamondHalvingBlock(CZDiamondReleaseHalfLife, _from);
        uint256 endSkipBlock = getPreviousCZDiamondHalvingBlock(CZDiamondReleaseHalfLife, _to);

        // In this case we do span multiple eras (at least 1 complete half-life era)
        if (startSkipBlock != endSkipBlock) {
            uint256 numberOfCompleteHalfLifes = getNumberOfHalvingsSinceStart(CZDiamondReleaseHalfLife, endSkipBlock) - getNumberOfHalvingsSinceStart(CZDiamondReleaseHalfLife, startSkipBlock);
            uint256 partialEndsRelease = startReleaseE24 * (startSkipBlock - _from) + (endReleaseE24 * (_to - endSkipBlock));
            uint256 wholeMiddleRelease = (endReleaseE24 * 2 * CZDiamondReleaseHalfLife) * ((2 ** numberOfCompleteHalfLifes) - 1);
            return (partialEndsRelease + wholeMiddleRelease) / 1e24;
        }

        // In this case we just span across 2 adjacent eras
        return ((endReleaseE24 * releaseDuration) + (startReleaseE24 - endReleaseE24) * (startSkipBlock - _from)) / 1e24;
    }

    function getDarksideEmissionForBlock(uint256 _block, bool isIncreasingGradient, uint256 releaseGradient, uint256 gradientEndBlock, uint256 endEmission) public pure returns (uint256) {
        if (_block >= gradientEndBlock)
            return endEmission;

        if (releaseGradient == 0)
            return endEmission;
        uint256 currentDarksideEmission = endEmission;
        uint256 deltaHeight = (releaseGradient * (gradientEndBlock - _block)) / 1e24;

        if (isIncreasingGradient) {
            // if there is a logical error, we return 0
            if (endEmission >= deltaHeight)
                currentDarksideEmission = endEmission - deltaHeight;
            else
                currentDarksideEmission = 0;
        } else
            currentDarksideEmission = endEmission + deltaHeight;

        return currentDarksideEmission;
    }

    function calcEmissionGradient(uint256 _block, uint256 currentEmission, uint256 gradientEndBlock, uint256 endEmission) external pure returns (uint256) {
        uint256 darksideReleaseGradient;

        // if the gradient is 0 we interpret that as an unchanging 0 gradient.
        if (currentEmission != endEmission && _block < gradientEndBlock) {
            bool isIncreasingGradient = endEmission > currentEmission;
            if (isIncreasingGradient)
                darksideReleaseGradient = ((endEmission - currentEmission) * 1e24) / (gradientEndBlock - _block);
            else
                darksideReleaseGradient = ((currentEmission - endEmission) * 1e24) / (gradientEndBlock - _block);
        } else
            darksideReleaseGradient = 0;

        return darksideReleaseGradient;
    }

    // Return if we are in the normal operation era, no promo
    function isFlatEmission(uint256 _gradientEndBlock, uint256 _blocknum) internal pure returns (bool) {
        return _blocknum >= _gradientEndBlock;
    }

    // Return DARKSIDE reward release over the given _from to _to block.
    function getDarksideRelease(bool isIncreasingGradient, uint256 releaseGradient, uint256 gradientEndBlock, uint256 endEmission, uint256 _from, uint256 _to) external view returns (uint256) {
        if (_to <= _from || _to <= startBlock)
            return 0;
        uint256 clippedFrom = _from < startBlock ? startBlock : _from;
        uint256 totalWidth = _to - clippedFrom;

        if (releaseGradient == 0 || isFlatEmission(gradientEndBlock, clippedFrom))
            return totalWidth * endEmission;

        if (!isFlatEmission(gradientEndBlock, _to)) {
            uint256 heightDelta = releaseGradient * totalWidth;

            uint256 baseEmission;
            if (isIncreasingGradient)
                baseEmission = getDarksideEmissionForBlock(clippedFrom, isIncreasingGradient, releaseGradient, gradientEndBlock, endEmission);
            else
                baseEmission = getDarksideEmissionForBlock(_to, isIncreasingGradient, releaseGradient, gradientEndBlock, endEmission);
            return totalWidth * baseEmission + (((totalWidth * heightDelta) / 2) / 1e24);
        }

        // Special case when we are transitioning between promo and normal era.
        if (!isFlatEmission(gradientEndBlock, clippedFrom) && isFlatEmission(gradientEndBlock, _to)) {
            uint256 blocksUntilGradientEnd = gradientEndBlock - clippedFrom;
            uint256 heightDelta = releaseGradient * blocksUntilGradientEnd;

            uint256 baseEmission;
            if (isIncreasingGradient)
                baseEmission = getDarksideEmissionForBlock(_to, isIncreasingGradient, releaseGradient, gradientEndBlock, endEmission);
            else
                baseEmission = getDarksideEmissionForBlock(clippedFrom, isIncreasingGradient, releaseGradient, gradientEndBlock, endEmission);

            return totalWidth * baseEmission - (((blocksUntilGradientEnd * heightDelta) / 2) / 1e24);
        }

        // huh?
        // shouldnt happen, but also don't want to assert false here either.
        return 0;
    }
}


// File contracts/CZDiamondToken.sol

// 

pragma solidity ^0.8.0;




// CZDiamondToken
contract CZDiamondToken is ERC20("CZDiamond", "CZDIAMOND") {

    // Burn address
    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;

    uint256 public constant usdcSwapThreshold = 20 * (10 ** 6);

    uint256 public pendingUSDC = 0;

    IERC20 public immutable usdcRewardCurrency;

    DarksideToolBox public immutable darksideToolBox;

    IUniswapV2Router02 public darksideSwapRouter;

    uint256 public lastUSDCDistroBlock = type(uint256).max;

    // default to two weeks @ 1600 blocks per hour
    uint256 public distributionTimeFrameBlocks = 1600 * 24 * 14;

    bool public ownershipIsTransferred = false;

    // Events
    event DistributeCZDiamond(address recipient, uint256 CZDiamondAmount);
    event DepositFeeConvertedToUSDC(address indexed inputToken, uint256 inputAmount, uint256 usdcOutput);
    event USDCTransferredToUser(address recipient, uint256 usdcAmount);
    event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
    event DarksideSwapRouterUpdated(address indexed operator, address indexed router);
    event SetUSDCDistributionTimeFrame(uint256 distributionTimeFrameBlocks);

    // The operator can only update the transfer tax rate
    address public operator;

    modifier onlyOperator() {
        require(operator == msg.sender, "operator: caller is not the operator");
        _;
    }

    /**
     * @notice Constructs the DarksideToken contract.
     */
    constructor(address _usdcCurrency, DarksideToolBox _darksideToolBox) public {
        operator = _msgSender();
        emit OperatorTransferred(address(0), operator);

        darksideToolBox = _darksideToolBox;
        usdcRewardCurrency = IERC20(_usdcCurrency);

        lastUSDCDistroBlock = _darksideToolBox.startBlock();

        // Divvy up CZDiamond supply.
        _mint(0x3a1D1114269d7a786C154FE5278bF5b1e3e20d31, 60 * (10 ** 3) * (10 ** 18));
        _mint(address(this), 40 * (10 ** 3) * (10 ** 18));
    }


    function transferOwnership(address newOwner) public override onlyOwner  {
        require(!ownershipIsTransferred, "!unset");
        super.transferOwnership(newOwner);
        ownershipIsTransferred = true;
    }

    /// @notice Sends `_amount` token to `_to`. Must only be called by the owner (MasterChef).
    function distribute(address _to, uint256 _amount) external onlyOwner returns (uint256){
        require(ownershipIsTransferred, "too early!");
        uint256 sendAmount = _amount;
        if (balanceOf(address(this)) < _amount)
            sendAmount = balanceOf(address(this));

        if (sendAmount > 0) {
            IERC20(address(this)).transfer(_to, sendAmount);
            emit DistributeCZDiamond(_to, sendAmount);
        }

        return sendAmount;
    }

    // To receive MATIC from darksideSwapRouter when swapping
    receive() external payable {}

    /**
     * @dev sell all of a current type of token for usdc. and distribute on a drip.
     * Can only be called by the current owner.
     */
    function getUSDCDripRate() external view returns (uint256) {
        return usdcRewardCurrency.balanceOf(address(this)) / distributionTimeFrameBlocks;
    }

    /**
     * @dev sell all of a current type of token for usdc. and distribute on a drip.
     * Can only be called by the current owner.
     */
    function getUSDCDrip() external onlyOwner returns (uint256) {
        uint256 usdcBalance = usdcRewardCurrency.balanceOf(address(this));
        if (pendingUSDC > usdcBalance)
            return 0;

        uint256 usdcAvailable = usdcBalance - pendingUSDC;

        // only provide a drip if there has been some blocks passed since the last drip
        uint256 blockSinceLastDistro = block.number > lastUSDCDistroBlock ? block.number - lastUSDCDistroBlock : 0;

        // We distribute the usdc assuming the old usdc balance wanted to be distributed over distributionTimeFrameBlocks blocks.
        uint256 usdcRelease = (blockSinceLastDistro * usdcAvailable) / distributionTimeFrameBlocks;

        usdcRelease = usdcRelease > usdcAvailable ? usdcAvailable : usdcRelease;

        lastUSDCDistroBlock = block.number;
        pendingUSDC += usdcRelease;

        return usdcRelease;
    }

    /**
     * @dev sell all of a current type of token for usdc.
     */
    function convertDepositFeesToUSDC(address token, uint256 tokenType) public onlyOwner {
        // shouldn't be trying to sell CZDiamond
        if (token == address(this) || token == address(usdcRewardCurrency))
            return;

        // LP tokens aren't destroyed in CZDiamond, but this is so CZDiamond can process
        // already destroyed LP fees sent to it by the DarksideToken contract.
        if (tokenType == 1) {
            convertDepositFeesToUSDC(IUniswapV2Pair(token).token0(), 0);
            convertDepositFeesToUSDC(IUniswapV2Pair(token).token1(), 0);
            return;
        }

        uint256 totalTokenBalance = IERC20(token).balanceOf(address(this));

        uint256 usdcValue = darksideToolBox.getTokenUSDCValue(totalTokenBalance, token, tokenType, false, address(usdcRewardCurrency));

        if (totalTokenBalance == 0)
            return;
        if (usdcValue < usdcSwapThreshold)
            return;

        // generate the darksideSwap pair path of token -> usdc.
        address[] memory path = new address[](2);
        path[0] = token;
        path[1] = address(usdcRewardCurrency);

        uint256 usdcPriorBalance = usdcRewardCurrency.balanceOf(address(this));

        require(IERC20(token).approve(address(darksideSwapRouter), totalTokenBalance), 'approval failed');

        try
            // make the swap
            darksideSwapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(
                totalTokenBalance,
                0, // accept any amount of USDC
                path,
                address(this),
                block.timestamp
            )
        { /* suceeded */ } catch { /* failed, but we avoided reverting */ }


        uint256 usdcProfit = usdcRewardCurrency.balanceOf(address(this)) - usdcPriorBalance;

        emit DepositFeeConvertedToUSDC(token, totalTokenBalance, usdcProfit);
    }

    /**
     * @dev send usdc to a user
     * Can only be called by the current operator.
     */
    function transferUSDCToUser(address recipient, uint256 amount) external onlyOwner {
       uint256 usdcBalance = usdcRewardCurrency.balanceOf(address(this));
       if (usdcBalance < amount)
           amount = usdcBalance;

       require(usdcRewardCurrency.transfer(recipient, amount), "transfer failed!");

       pendingUSDC -= amount;

        emit USDCTransferredToUser(recipient, amount);
    }

    /**
     * @dev set the number of blocks we should use to calculate the USDC drip rate.
     * Can only be called by the current operator.
     */
    function setUSDCDistributionTimeFrame(uint256 _usdcDistributionTimeFrame) external onlyOperator {
        require(_usdcDistributionTimeFrame > 1600 && _usdcDistributionTimeFrame < 70080000 /* 5 years */, "_usdcDistributionTimeFrame out of range!");

        distributionTimeFrameBlocks = _usdcDistributionTimeFrame;

        emit SetUSDCDistributionTimeFrame(distributionTimeFrameBlocks);
    }

    /**
     * @dev Update the swap router.
     * Can only be called by the current operator.
     */
    function updateDarksideSwapRouter(address _router) external onlyOperator {
        require(_router != address(0), "updateDarksideSwapRouter: new _router is the zero address");
        require(address(darksideSwapRouter) == address(0), "router already set!");

        darksideSwapRouter = IUniswapV2Router02(_router);
        emit DarksideSwapRouterUpdated(msg.sender, address(darksideSwapRouter));
    }

    /**
     * @dev Transfers operator of the contract to a new account (`newOperator`).
     * Can only be called by the current operator.
     */
    function transferOperator(address newOperator) external onlyOperator {
        require(newOperator != address(0), "transferOperator: new operator is the zero address");

        emit OperatorTransferred(operator, newOperator);

        operator = newOperator;
    }
}


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

// 

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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

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


// File contracts/libs/SafeERC20.sol

// 

pragma solidity ^0.8.0;


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

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

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

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

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

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

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

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


// File contracts/libs/IDarksideReferral.sol

// 

pragma solidity ^0.8.0;

interface IDarksideReferral {
    /**
     * @dev Record referral.
     */
    function recordReferral(address user, address referrer) external;

    /**
     * @dev Record referral commission.
     */
    function recordReferralCommission(address referrer, uint256 commission) external;

    /**
     * @dev Get the referrer address that referred the user.
     */
    function getReferrer(address user) external view returns (address);
}


// File contracts/DarksideReferral.sol

// 

pragma solidity ^0.8.0;




contract DarksideReferral is IDarksideReferral, Ownable {

    address public operator;

    mapping(address => address) public referrers; // user address => referrer address
    mapping(address => uint256) public referralsCount; // referrer address => referrals count
    mapping(address => uint256) public totalReferralCommissions; // referrer address => total referral commissions

    event ReferralRecorded(address indexed user, address indexed referrer);
    event ReferralCommissionRecorded(address indexed referrer, uint256 commission);
    event OperatorUpdated(address indexed operator);

    modifier onlyOperator {
        require(operator == msg.sender, "Operator: caller is not the operator");
        _;
    }

    function recordReferral(address _user, address _referrer) external override onlyOperator {
        if (_user != address(0)
            && _referrer != address(0)
            && _user != _referrer
            && referrers[_user] == address(0)
        ) {
            referrers[_user] = _referrer;
            referralsCount[_referrer] += 1;
            emit ReferralRecorded(_user, _referrer);
        }
    }

    function recordReferralCommission(address _referrer, uint256 _commission) external override onlyOperator {
        if (_referrer != address(0) && _commission > 0) {
            totalReferralCommissions[_referrer] += _commission;
            emit ReferralCommissionRecorded(_referrer, _commission);
        }
    }

    // Get the referrer address that referred the user
    function getReferrer(address _user) external override view returns (address) {
        return referrers[_user];
    }

    // Update the status of the operator
    function updateOperator(address _operator) external onlyOwner {
        require(_operator != address(0), "operator cannot be the 0 address");
        require(operator == address(0), "operator is already set!");

        operator = _operator;

        emit OperatorUpdated(_operator);
    }
}


// File contracts/libs/IWETH.sol

pragma solidity >=0.5.0;

interface IWETH {
    function deposit() external payable;
    function transfer(address to, uint value) external returns (bool);
    function withdraw(uint) external;
}


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

// 

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
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() {
        _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;
    }
}


// File contracts/libs/AddLiquidityHelper.sol

// 

pragma solidity ^0.8.0;





// AddLiquidityHelper, allows anyone to add or remove Darkside liquidity tax free
// Also allows the Darkside Token to do buy backs tax free via an external contract.
contract AddLiquidityHelper is ReentrancyGuard, Ownable {
    using SafeERC20 for ERC20;

    address public darksideAddress;

    IUniswapV2Router02 public immutable darksideSwapRouter;
    // The trading pair
    address public darksideSwapPair;

    // To receive ETH when swapping
    receive() external payable {}

    event SetDarksideAddresses(address darksideAddress, address darksideSwapPair);

    /**
     * @notice Constructs the AddLiquidityHelper contract.
     */
    constructor(address _router) public  {
        require(_router != address(0), "_router is the zero address");
        darksideSwapRouter = IUniswapV2Router02(_router);
    }

    function darksideETHLiquidityWithBuyBack(address lpHolder) external payable nonReentrant {
        require(msg.sender == darksideAddress, "can only be used by the darkside token!");

        (uint256 res0, uint256 res1, ) = IUniswapV2Pair(darksideSwapPair).getReserves();

        if (res0 != 0 && res1 != 0) {
            // making weth res0
            if (IUniswapV2Pair(darksideSwapPair).token0() == darksideAddress)
                (res1, res0) = (res0, res1);

            uint256 contractTokenBalance = ERC20(darksideAddress).balanceOf(address(this));

            // calculate how much eth is needed to use all of contractTokenBalance
            // also boost precision a tad.
            uint256 totalETHNeeded = (res0 * contractTokenBalance) / res1;

            uint256 existingETH = address(this).balance;

            uint256 unmatchedDarkside = 0;

            if (existingETH < totalETHNeeded) {
                // calculate how much darkside will match up with our existing eth.
                uint256 matchedDarkside = (res1 * existingETH) / res0;
                if (contractTokenBalance >= matchedDarkside)
                    unmatchedDarkside = contractTokenBalance - matchedDarkside;
            } else if (existingETH > totalETHNeeded) {
                // use excess eth for darkside buy back
                uint256 excessETH = existingETH - totalETHNeeded;

                if (excessETH / 2 > 0) {
                    // swap half of the excess eth for lp to be balanced
                    swapETHForTokens(excessETH / 2, darksideAddress);
                }
            }

            uint256 unmatchedDarksideToSwap = unmatchedDarkside / 2;

            // swap tokens for ETH
            if (unmatchedDarksideToSwap > 0)
                swapTokensForEth(darksideAddress, unmatchedDarksideToSwap);

            uint256 darksideBalance = ERC20(darksideAddress).balanceOf(address(this));

            // approve token transfer to cover all possible scenarios
            ERC20(darksideAddress).approve(address(darksideSwapRouter), darksideBalance);

            // add the liquidity
            darksideSwapRouter.addLiquidityETH{value: address(this).balance}(
                darksideAddress,
                darksideBalance,
                0, // slippage is unavoidable
                0, // slippage is unavoidable
                lpHolder,
                block.timestamp
            );

        }

        if (address(this).balance > 0) {
            // not going to require/check return value of this transfer as reverting behaviour is undesirable.
            payable(address(msg.sender)).call{value: address(this).balance}("");
        }

        if (ERC20(darksideAddress).balanceOf(address(this)) > 0)
            ERC20(darksideAddress).transfer(msg.sender, ERC20(darksideAddress).balanceOf(address(this)));
    }

    function addDarksideETHLiquidity(uint256 nativeAmount) external payable nonReentrant {
        require(msg.value > 0, "!sufficient funds");

        ERC20(darksideAddress).safeTransferFrom(msg.sender, address(this), nativeAmount);

        // approve token transfer to cover all possible scenarios
        ERC20(darksideAddress).approve(address(darksideSwapRouter), nativeAmount);

        // add the liquidity
        darksideSwapRouter.addLiquidityETH{value: msg.value}(
            darksideAddress,
            nativeAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            msg.sender,
            block.timestamp
        );

        if (address(this).balance > 0) {
            // not going to require/check return value of this transfer as reverting behaviour is undesirable.
            payable(address(msg.sender)).call{value: address(this).balance}("");
        }

        uint256 darksideBalance = ERC20(darksideAddress).balanceOf(address(this));

        if (darksideBalance > 0)
            ERC20(darksideAddress).transfer(msg.sender, darksideBalance);
    }

    function addDarksideLiquidity(address baseTokenAddress, uint256 baseAmount, uint256 nativeAmount) external nonReentrant {
        ERC20(baseTokenAddress).safeTransferFrom(msg.sender, address(this), baseAmount);
        ERC20(darksideAddress).safeTransferFrom(msg.sender, address(this), nativeAmount);

        // approve token transfer to cover all possible scenarios
        ERC20(baseTokenAddress).approve(address(darksideSwapRouter), baseAmount);
        ERC20(darksideAddress).approve(address(darksideSwapRouter), nativeAmount);

        // add the liquidity
        darksideSwapRouter.addLiquidity(
            baseTokenAddress,
            darksideAddress,
            baseAmount,
            nativeAmount ,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            msg.sender,
            block.timestamp
        );

        if (ERC20(baseTokenAddress).balanceOf(address(this)) > 0)
            ERC20(baseTokenAddress).safeTransfer(msg.sender, ERC20(baseTokenAddress).balanceOf(address(this)));

        if (ERC20(darksideAddress).balanceOf(address(this)) > 0)
            ERC20(darksideAddress).transfer(msg.sender, ERC20(darksideAddress).balanceOf(address(this)));
    }

    function removeDarksideLiquidity(address baseTokenAddress, uint256 liquidity) external nonReentrant {
        address lpTokenAddress = IUniswapV2Factory(darksideSwapRouter.factory()).getPair(baseTokenAddress, darksideAddress);
        require(lpTokenAddress != address(0), "pair hasn't been created yet, so can't remove liquidity!");

        ERC20(lpTokenAddress).safeTransferFrom(msg.sender, address(this), liquidity);
        // approve token transfer to cover all possible scenarios
        ERC20(lpTokenAddress).approve(address(darksideSwapRouter), liquidity);

        // add the liquidity
        darksideSwapRouter.removeLiquidity(
            baseTokenAddress,
            darksideAddress,
            liquidity,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            msg.sender,
            block.timestamp
        );
    }

    /// @dev Swap tokens for eth
    function swapTokensForEth(address saleTokenAddress, uint256 tokenAmount) internal {
        // generate the darksideSwap pair path of token -> weth
        address[] memory path = new address[](2);
        path[0] = saleTokenAddress;
        path[1] = darksideSwapRouter.WETH();

        ERC20(saleTokenAddress).approve(address(darksideSwapRouter), tokenAmount);

        // make the swap
        darksideSwapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // accept any amount of ETH
            path,
            address(this),
            block.timestamp
        );
    }


    function swapETHForTokens(uint256 ethAmount, address wantedTokenAddress) internal {
        require(address(this).balance >= ethAmount, "insufficient matic provided!");
        require(wantedTokenAddress != address(0), "wanted token address can't be the zero address!");

        // generate the darksideSwap pair path of token -> weth
        address[] memory path = new address[](2);
        path[0] = darksideSwapRouter.WETH();
        path[1] = wantedTokenAddress;

        // make the swap
        darksideSwapRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{value: ethAmount}(
            0,
            path,
            // cannot send tokens to the token contract of the same type as the output token
            address(this),
            block.timestamp
        );
    }

    /**
     * @dev set the darkside address.
     * Can only be called by the current owner.
     */
    function setDarksideAddress(address _darksideAddress) external onlyOwner {
        require(_darksideAddress != address(0), "_darksideAddress is the zero address");
        require(darksideAddress == address(0), "darksideAddress already set!");

        darksideAddress = _darksideAddress;

        darksideSwapPair = IUniswapV2Factory(darksideSwapRouter.factory()).getPair(darksideAddress, darksideSwapRouter.WETH());

        require(address(darksideSwapPair) != address(0), "matic pair !exist");

        emit SetDarksideAddresses(darksideAddress, darksideSwapPair);
    }
}


// File contracts/DarksideToken.sol

// 

pragma solidity ^0.8.0;







// DarksideToken.
contract DarksideToken is ERC20("Darkcoin", "DARK")  {
    using SafeERC20 for IERC20;

    // Transfer tax rate in basis points. (default 6.66%)
    uint16 public transferTaxRate = 666;
    // Extra transfer tax rate in basis points. (default 10.00%)
    uint16 public extraTransferTaxRate = 1000;
    // Burn rate % of transfer tax. (default 54.95% x 6.66% = 3.660336% of total amount).
    uint32 public constant burnRate = 549549549;
    // Max transfer tax rate: 20.00%.
    uint16 public constant MAXIMUM_TRANSFER_TAX_RATE = 2000;
    // Burn address
    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;

    address public constant usdcCurrencyAddress = 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174;

    uint256 public constant usdcSwapThreshold = 20 * (10 ** 6);

    // Min amount to liquify. (default 40 DARKSIDEs)
    uint256 public constant minDarksideAmountToLiquify = 40 * (10 ** 18);
    // Min amount to liquify. (default 100 MATIC)
    uint256 public constant minMaticAmountToLiquify = 100 *  (10 ** 18);

    IUniswapV2Router02 public darksideSwapRouter;
    // The trading pair
    address public darksideSwapPair;
    // In swap and liquify
    bool private _inSwapAndLiquify;

    AddLiquidityHelper public immutable addLiquidityHelper;
    DarksideToolBox public immutable darksideToolBox;

    address public immutable CZDiamond;

    bool public ownershipIsTransferred = false;

    mapping(address => bool) public excludeFromMap;
    mapping(address => bool) public excludeToMap;

    mapping(address => bool) public extraFromMap;
    mapping(address => bool) public extraToMap;

    event TransferFeeChanged(uint256 txnFee, uint256 extraTxnFee);
    event UpdateFeeMaps(address indexed _contract, bool fromExcluded, bool toExcluded, bool fromHasExtra, bool toHasExtra);
    event SetDarksideRouter(address darksideSwapRouter, address darksideSwapPair);
    event OperatorTransferred(address indexed previousOperator, address indexed newOperator);

    // The operator can only update the transfer tax rate
    address public operator;

    modifier onlyOperator() {
        require(operator == msg.sender, "!operator");
        _;
    }

    modifier lockTheSwap {
        _inSwapAndLiquify = true;
        _;
        _inSwapAndLiquify = false;
    }

    modifier transferTaxFree {
        uint16 _transferTaxRate = transferTaxRate;
        uint16 _extraTransferTaxRate = extraTransferTaxRate;
        transferTaxRate = 0;
        extraTransferTaxRate = 0;
        _;
        transferTaxRate = _transferTaxRate;
        extraTransferTaxRate = _extraTransferTaxRate;
    }

    /**
     * @notice Constructs the DarksideToken contract.
     */
    constructor(address _CZDiamond, AddLiquidityHelper _addLiquidityHelper, DarksideToolBox _darksideToolBox) public {
        addLiquidityHelper = _addLiquidityHelper;
        darksideToolBox = _darksideToolBox;
        CZDiamond = _CZDiamond;
        operator = _msgSender();

        // pre-mint
        _mint(address(0x3a1D1114269d7a786C154FE5278bF5b1e3e20d31), uint256(325000 * (10 ** 18)));
    }

    function transferOwnership(address newOwner) public override onlyOwner  {
        require(!ownershipIsTransferred, "!unset");
        super.transferOwnership(newOwner);
        ownershipIsTransferred = true;
    }

    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
    function burn(uint256 _amount) external onlyOwner {
        _burn(msg.sender, _amount);
    }

    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
    function mint(address _to, uint256 _amount) external onlyOwner {
        require(ownershipIsTransferred, "too early!");
        if (_amount > 0)
            _mint(_to, _amount);
    }

    /// @dev overrides transfer function to meet tokenomics of DARKSIDE
    function _transfer(address sender, address recipient, uint256 amount) internal virtual override {
        bool toFromAddLiquidityHelper = (sender == address(addLiquidityHelper) || recipient == address(addLiquidityHelper));
        // swap and liquify
        if (
            _inSwapAndLiquify == false
            && address(darksideSwapRouter) != address(0)
            && !toFromAddLiquidityHelper
            && sender != darksideSwapPair
            && sender != owner()
        ) {
            swapAndLiquify();
        }

        if (toFromAddLiquidityHelper ||
            recipient == BURN_ADDRESS || (transferTaxRate == 0 && extraTransferTaxRate == 0) ||
            excludeFromMap[sender] || excludeToMap[recipient]) {
            super._transfer(sender, recipient, amount);
        } else {
            // default tax is 6.66% of every transfer, but extra 2% for dumping tax
            uint256 taxAmount = (amount * (transferTaxRate +
                ((extraFromMap[sender] || extraToMap[recipient]) ? extraTransferTaxRate : 0))) / 10000;

            uint256 burnAmount = (taxAmount * burnRate) / 1000000000;
            uint256 liquidityAmount = taxAmount - burnAmount;

            // default 93.34% of transfer sent to recipient
            uint256 sendAmount = amount - taxAmount;

            assert(amount == sendAmount + taxAmount &&
                        taxAmount == burnAmount + liquidityAmount);

            super._transfer(sender, BURN_ADDRESS, burnAmount);
            super._transfer(sender, address(this), liquidityAmount);
            super._transfer(sender, recipient, sendAmount);
            amount = sendAmount;
        }
    }

    /// @dev Swap and liquify
    function swapAndLiquify() private lockTheSwap transferTaxFree {
        uint256 contractTokenBalance = ERC20(address(this)).balanceOf(address(this));

        uint256 WETHbalance = IERC20(darksideSwapRouter.WETH()).balanceOf(address(this));

        IWETH(darksideSwapRouter.WETH()).withdraw(WETHbalance);

        if (address(this).balance >= minMaticAmountToLiquify || contractTokenBalance >= minDarksideAmountToLiquify) {

            IERC20(address(this)).safeTransfer(address(addLiquidityHelper), IERC20(address(this)).balanceOf(address(this)));
            // send all tokens to add liquidity with, we are refunded any that aren't used.
            addLiquidityHelper.darksideETHLiquidityWithBuyBack{value: address(this).balance}(BURN_ADDRESS);
        }
    }

    /**
     * @dev unenchant the lp token into its original components.
     * Can only be called by the current operator.
     */
    function swapLpTokensForFee(address token, uint256 amount) internal {
        require(IERC20(token).approve(address(darksideSwapRouter), amount), '!approved');

        IUniswapV2Pair lpToken = IUniswapV2Pair(token);

        uint256 token0BeforeLiquidation = IERC20(lpToken.token0()).balanceOf(address(this));
        uint256 token1BeforeLiquidation = IERC20(lpToken.token1()).balanceOf(address(this));

        // make the swap
        darksideSwapRouter.removeLiquidity(
            lpToken.token0(),
            lpToken.token1(),
            amount,
            0,
            0,
            address(this),
            block.timestamp
        );

        uint256 token0FromLiquidation = IERC20(lpToken.token0()).balanceOf(address(this)) - token0BeforeLiquidation;
        uint256 token1FromLiquidation = IERC20(lpToken.token1()).balanceOf(address(this)) - token1BeforeLiquidation;

        address tokenForCZDiamondUSDCReward = lpToken.token0();
        address tokenForDarksideAMMReward = lpToken.token1();

        // If we already have, usdc, save a swap.
       if (lpToken.token1() == usdcCurrencyAddress){

            (tokenForDarksideAMMReward, tokenForCZDiamondUSDCReward) = (tokenForCZDiamondUSDCReward, tokenForDarksideAMMReward);
        } else if (lpToken.token0() == darksideSwapRouter.WETH()){
            // if one is weth already use the other one for czdiamond and
            // the weth for darkside AMM to save a swap.

            (tokenForDarksideAMMReward, tokenForCZDiamondUSDCReward) = (tokenForCZDiamondUSDCReward, tokenForDarksideAMMReward);
        }

        bool czRewardIs0 = tokenForCZDiamondUSDCReward == lpToken.token0();

        // send czdiamond all of 1 half of the LP to be convereted to USDC later.
        IERC20(tokenForCZDiamondUSDCReward).safeTransfer(address(CZDiamond),
            czRewardIs0 ? token0FromLiquidation : token1FromLiquidation);

        // send czdiamond 50% share of the other 50% to give czdiamond 75% in total.
        IERC20(tokenForDarksideAMMReward).safeTransfer(address(CZDiamond),
            (czRewardIs0 ? token1FromLiquidation : token0FromLiquidation)/2);

        swapDepositFeeForWmatic(tokenForDarksideAMMReward, 0);
    }

    /**
     * @dev sell all of a current type of token for weth, to be used in darkside liquidity later.
     * Can only be called by the current operator.
     */
    function swapDepositFeeForETH(address token, uint256 tokenType) external onlyOwner {
        uint256 usdcValue = darksideToolBox.getTokenUSDCValue(IERC20(token).balanceOf(address(this)), token, tokenType, false, usdcCurrencyAddress);

        // If darkside or weth already no need to do anything.
        if (token == address(this) || token == darksideSwapRouter.WETH())
            return;

        // only swap if a certain usdc value
        if (usdcValue < usdcSwapThreshold)
            return;

        swapDepositFeeForWmatic(token, tokenType);
    }

    function swapDepositFeeForWmatic(address token, uint256 tokenType) internal {
        address toToken = darksideSwapRouter.WETH();
        uint256 totalTokenBalance = IERC20(token).balanceOf(address(this));

        // can't trade to darkside inside of darkside anyway
        if (token == toToken || totalTokenBalance == 0 || toToken == address(this))
            return;

        if (tokenType == 1) {
            swapLpTokensForFee(token, totalTokenBalance);
            return;
        }

        require(IERC20(token).approve(address(darksideSwapRouter), totalTokenBalance), "!approved");

        // generate the darksideSwap pair path of token -> weth
        address[] memory path = new address[](2);
        path[0] = token;
        path[1] = toToken;

        try
            // make the swap
            darksideSwapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(
                totalTokenBalance,
                0, // accept any amount of tokens
                path,
                address(this),
                block.timestamp
            )
        { /* suceeded */ } catch { /* failed, but we avoided reverting */ }

        // Unfortunately can't swap directly to darkside inside of darkside (Uniswap INVALID_TO Assert, boo).
        // Also dont want to add an extra swap here.
        // Will leave as WETH and make the darkside Txn AMM utilise available WETH first.
    }

    // To receive ETH from darksideSwapRouter when swapping
    receive() external payable {}

    /**
     * @dev Update the transfer tax rate.
     * Can only be called by the current operator.
     */
    function updateTransferTaxRate(uint16 _transferTaxRate, uint16 _extraTransferTaxRate) external onlyOperator {
        require(_transferTaxRate + _extraTransferTaxRate  <= MAXIMUM_TRANSFER_TAX_RATE,
            "!valid");
        transferTaxRate = _transferTaxRate;
        extraTransferTaxRate = _extraTransferTaxRate;

        emit TransferFeeChanged(transferTaxRate, extraTransferTaxRate);
    }

    /**
     * @dev Update the excludeFromMap
     * Can only be called by the current operator.
     */
    function updateFeeMaps(address _contract, bool fromExcluded, bool toExcluded, bool fromHasExtra, bool toHasExtra) external onlyOperator {
        excludeFromMap[_contract] = fromExcluded;
        excludeToMap[_contract] = toExcluded;
        extraFromMap[_contract] = fromHasExtra;
        extraToMap[_contract] = toHasExtra;

        emit UpdateFeeMaps(_contract, fromExcluded, toExcluded, fromHasExtra, toHasExtra);
    }

    /**
     * @dev Update the swap router.
     * Can only be called by the current operator.
     */
    function updateDarksideSwapRouter(address _router) external onlyOperator {
        require(_router != address(0), "!!0");
        require(address(darksideSwapRouter) == address(0), "!unset");

        darksideSwapRouter = IUniswapV2Router02(_router);
        darksideSwapPair = IUniswapV2Factory(darksideSwapRouter.factory()).getPair(address(this), darksideSwapRouter.WETH());

        require(address(darksideSwapPair) != address(0), "!matic pair");

        emit SetDarksideRouter(address(darksideSwapRouter), darksideSwapPair);
    }

    /**
     * @dev Transfers operator of the contract to a new account (`newOperator`).
     * Can only be called by the current operator.
     */
    function transferOperator(address newOperator) external onlyOperator {
        require(newOperator != address(0), "!!0");

        emit OperatorTransferred(operator, newOperator);

        operator = newOperator;
    }
}


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

// 

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


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

// 

pragma solidity ^0.8.0;

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}


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

// 

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}


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

// 

pragma solidity ^0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}


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

// 

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}


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

// 

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}


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

// 

pragma solidity ^0.8.0;







/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver(to).onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` 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 tokenId
    ) internal virtual {}
}


// File contracts/libs/ERC721Wrapper.sol

contract ERC721Wrapper is ERC721{

    // FOR TESTING ONLY NOT FOR AUDIT!!!

    constructor(string memory name_, string memory symbol_) public ERC721(name_, symbol_) {
    }
}


// File hardhat/[email protected]

// 
pragma solidity >= 0.4.22 <0.9.0;

library console {
	address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);

	function _sendLogPayload(bytes memory payload) private view {
		uint256 payloadLength = payload.length;
		address consoleAddress = CONSOLE_ADDRESS;
		assembly {
			let payloadStart := add(payload, 32)
			let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
		}
	}

	function log() internal view {
		_sendLogPayload(abi.encodeWithSignature("log()"));
	}

	function logInt(int p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(int)", p0));
	}

	function logUint(uint p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
	}

	function logString(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function logBool(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function logAddress(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function logBytes(bytes memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
	}

	function logBytes1(bytes1 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
	}

	function logBytes2(bytes2 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
	}

	function logBytes3(bytes3 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
	}

	function logBytes4(bytes4 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
	}

	function logBytes5(bytes5 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
	}

	function logBytes6(bytes6 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
	}

	function logBytes7(bytes7 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
	}

	function logBytes8(bytes8 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
	}

	function logBytes9(bytes9 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
	}

	function logBytes10(bytes10 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
	}

	function logBytes11(bytes11 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
	}

	function logBytes12(bytes12 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
	}

	function logBytes13(bytes13 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
	}

	function logBytes14(bytes14 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
	}

	function logBytes15(bytes15 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
	}

	function logBytes16(bytes16 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
	}

	function logBytes17(bytes17 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
	}

	function logBytes18(bytes18 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
	}

	function logBytes19(bytes19 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
	}

	function logBytes20(bytes20 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
	}

	function logBytes21(bytes21 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
	}

	function logBytes22(bytes22 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
	}

	function logBytes23(bytes23 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
	}

	function logBytes24(bytes24 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
	}

	function logBytes25(bytes25 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
	}

	function logBytes26(bytes26 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
	}

	function logBytes27(bytes27 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
	}

	function logBytes28(bytes28 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
	}

	function logBytes29(bytes29 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
	}

	function logBytes30(bytes30 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
	}

	function logBytes31(bytes31 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
	}

	function logBytes32(bytes32 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
	}

	function log(uint p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
	}

	function log(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function log(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function log(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function log(uint p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
	}

	function log(uint p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
	}

	function log(uint p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
	}

	function log(uint p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
	}

	function log(string memory p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
	}

	function log(string memory p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
	}

	function log(string memory p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
	}

	function log(string memory p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
	}

	function log(bool p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
	}

	function log(bool p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
	}

	function log(bool p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
	}

	function log(bool p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
	}

	function log(address p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
	}

	function log(address p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
	}

	function log(address p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
	}

	function log(address p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
	}

	function log(uint p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
	}

	function log(uint p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
	}

	function log(uint p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
	}

	function log(uint p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
	}

	function log(uint p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
	}

	function log(uint p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
	}

	function log(uint p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
	}

	function log(uint p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
	}

	function log(uint p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
	}

	function log(uint p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
	}

	function log(uint p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
	}

	function log(uint p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
	}

	function log(string memory p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
	}

	function log(string memory p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
	}

	function log(string memory p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
	}

	function log(string memory p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
	}

	function log(bool p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
	}

	function log(bool p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
	}

	function log(bool p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
	}

	function log(bool p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
	}

	function log(bool p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
	}

	function log(bool p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
	}

	function log(bool p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
	}

	function log(bool p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
	}

	function log(bool p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
	}

	function log(bool p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
	}

	function log(bool p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
	}

	function log(bool p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
	}

	function log(address p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
	}

	function log(address p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
	}

	function log(address p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
	}

	function log(address p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
	}

	function log(address p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
	}

	function log(address p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
	}

	function log(address p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
	}

	function log(address p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
	}

	function log(address p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
	}

	function log(address p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
	}

	function log(address p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
	}

	function log(address p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
	}

	function log(address p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
	}

	function log(address p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
	}

	function log(address p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
	}

	function log(address p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
	}

	function log(uint p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
	}

}


// File contracts/libs/Multicall.sol

pragma solidity >=0.5.0;
pragma experimental ABIEncoderV2;

/// @title Multicall - Aggregate results from multiple read-only function calls
/// @author Michael Elliot <[email protected]>
/// @author Joshua Levine <[email protected]>
/// @author Nick Johnson <[email protected]>

contract Multicall {
    struct Call {
        address target;
        bytes callData;
    }

    // FOR TESTING ONLY NOT FOR AUDIT!!!

    function aggregate(Call[] memory calls) public returns (uint256 blockNumber, bytes[] memory returnData) {
        console.log("multicall is running!!!");
        blockNumber = block.number;
        returnData = new bytes[](calls.length);
        for(uint256 i = 0; i < calls.length; i++) {
            console.log("calling target: %s", calls[i].target);
            console.logBytes(calls[i].callData);
            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
            console.log("op %d returned", i);
            require(success, "multicall op FAILED");
            returnData[i] = ret;
        }
    }
    // Helper functions
    function getEthBalance(address addr) public view returns (uint256 balance) {
        balance = addr.balance;
    }
    function getBlockHash(uint256 blockNumber) public view returns (bytes32 blockHash) {
        blockHash = blockhash(blockNumber);
    }
    function getLastBlockHash() public view returns (bytes32 blockHash) {
        blockHash = blockhash(block.number - 1);
    }
    function getCurrentBlockTimestamp() public view returns (uint256 timestamp) {
        timestamp = block.timestamp;
    }
    function getCurrentBlockDifficulty() public view returns (uint256 difficulty) {
        difficulty = block.difficulty;
    }
    function getCurrentBlockGasLimit() public view returns (uint256 gaslimit) {
        gaslimit = block.gaslimit;
    }
    function getCurrentBlockCoinbase() public view returns (address coinbase) {
        coinbase = block.coinbase;
    }
}


// File contracts/Locker.sol

// The locker stores IERC20 tokens and only allows the owner to withdraw them after the UNLOCK_BLOCKNUMBER has been reached.


contract Locker is Ownable {
    using SafeERC20 for IERC20;

    uint256 public immutable UNLOCK_BLOCKNUMBER;

    event Claim(address token, address to);

    // ALREADY AUDITED !!!

    /**
     * @notice Constructs the DarksideToken contract.
     */
    constructor(uint256 blockNumber) public {
        UNLOCK_BLOCKNUMBER = blockNumber;
    }

    // claimToken allows the owner to withdraw tokens sent manually to this contract.
    // It is only callable once UNLOCK_BLOCKNUMBER has passed.
    function claimToken(address token, address to) external onlyOwner {
        require(block.number > UNLOCK_BLOCKNUMBER, "still vesting...");

        IERC20(token).safeTransfer(to, IERC20(token).balanceOf(address(this)));

        emit Claim(token, to);
    }
}


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

// 

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

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

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

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

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

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


// File contracts/NFTChef.sol

// 

pragma solidity ^0.8.0;






// NFTChef is the keeper of Masterchefs NFTs.
//
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract NFTChef is IERC721Receiver, Ownable {
    using EnumerableSet for EnumerableSet.UintSet;
    using SafeERC20 for IERC20;

    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external override returns(bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }

    // max NFTs a single user can stake in a pool. This is to ensure finite gas usage on emergencyWithdraw.
    uint256 public constant MAX_NFT_COUNT = 32;
    uint256 public constant MAX_MATIC_STAKING_FEE = 1e3 * (1e18);

    // Mapping of NFT contract address to which NFTs a user has staked.
    mapping(address => mapping(address => mapping(uint256 => bool))) public userStakedMap;
    // Mapping of NFT contract address to array of NFT IDs a user has staked.
    mapping(address => mapping(address => EnumerableSet.UintSet)) private userNftIdsMapArray;
    // mapping of NFT contract address to maticFeeAmount
    mapping(address => uint256) public userNftMaticFeeMap;

    // MATIC Polygon (MATIC) address
    address public constant maticCurrencyAddress = 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270;
    address public immutable CZDiamondAddress;
    address public immutable darksideAddress;

    event AddSetPoolNFT(address indexed nftContractAddress, uint256 maticFee);
    event DepositNFT(address indexed user, address indexed nftContractAddress, uint256 nftId);
    event WithdrawNFT(address indexed user, address indexed nftContractAddress, uint256 nftId);
    event EmergencyWithdrawNFT(address indexed user, address indexed nftContractAddress, uint256 nftId);
    event EmergencyNFTWithdrawCompleted(address indexed user, address indexed nftContractAddress, uint256 amountOfNfts);

    constructor(
        address _CZDiamondAddress,
        address _darksideAddress
    ) public {
        CZDiamondAddress = _CZDiamondAddress;
        darksideAddress = _darksideAddress;
    }

    // set NFTs matic deposit Fees.
    function setPoolMaticFee(address nftContractAddress, uint256 maticFee) external onlyOwner {
        IERC721(nftContractAddress).balanceOf(address(this));
        require(maticFee <= MAX_MATIC_STAKING_FEE, "maximum matic fee for nft staking is 1000 matic!");
        userNftMaticFeeMap[nftContractAddress] = maticFee;

        emit AddSetPoolNFT(nftContractAddress, maticFee);
    }

    // Deposit NFTs to NFTChef for DARKSIDE allocation.
    function deposit(address nftContractAddress, address userAddress, uint256 nftId) external payable onlyOwner {
        require(msg.value >= userNftMaticFeeMap[nftContractAddress], "not enough unwrapped matic provided!");
        require(userNftIdsMapArray[nftContractAddress][userAddress].length() < MAX_NFT_COUNT,
            "you have aleady reached the maximum amount of NFTs you can stake in this pool");
        IERC721(nftContractAddress).transferFrom(userAddress, address(this), nftId);

        userStakedMap[nftContractAddress][userAddress][nftId] = true;

        userNftIdsMapArray[nftContractAddress][userAddress].add(nftId);

        uint256 maticBalance = address(this).balance;
        // Wrapping native matic for wmatic.
        if (maticBalance > 0)
            IWETH(maticCurrencyAddress).deposit{value:maticBalance}();

        uint256 wmaticBalance = IERC20(maticCurrencyAddress).balanceOf(address(this));
        uint256 darkSideFee = wmaticBalance/4;

        if (darkSideFee > 0)
            IERC20(maticCurrencyAddress).safeTransferFrom(address(this), darksideAddress, darkSideFee);
        if (wmaticBalance - darkSideFee > 0)
            IERC20(maticCurrencyAddress).safeTransferFrom(address(this), CZDiamondAddress, wmaticBalance - darkSideFee);

        emit DepositNFT(userAddress, nftContractAddress, nftId);
    }

    // Withdraw NFTs from NFTChef.
    function withdraw(address nftContractAddress, address userAddress, uint256 nftId) external onlyOwner {
        require(userStakedMap[nftContractAddress][userAddress][nftId], "nft not staked");

        IERC721(nftContractAddress).transferFrom(address(this), userAddress, nftId);

        userStakedMap[nftContractAddress][userAddress][nftId] = false;

        userNftIdsMapArray[nftContractAddress][userAddress].remove(nftId);

        emit WithdrawNFT(userAddress, nftContractAddress, nftId);
    }

    // Withdraw all NFTs without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(address nftContractAddress, address userAddress) external onlyOwner {
        EnumerableSet.UintSet storage nftStakedCollection = userNftIdsMapArray[nftContractAddress][userAddress];

        for (uint256 i = 0;i < nftStakedCollection.length();i++) {
            uint256 nftId = nftStakedCollection.at(i);

            IERC721(nftContractAddress).transferFrom(address(this), userAddress, nftId);

            userStakedMap[nftContractAddress][userAddress][nftId] = false;

            emit EmergencyWithdrawNFT(userAddress, nftContractAddress, nftId);
        }

        emit EmergencyNFTWithdrawCompleted(userAddress, nftContractAddress, nftStakedCollection.length());

        // empty user nft Ids array
        delete userNftIdsMapArray[nftContractAddress][userAddress];
    }

    function viewStakerUserNFTs(address nftContractAddress, address userAddress) public view returns (uint256[] memory){
        EnumerableSet.UintSet storage nftStakedCollection = userNftIdsMapArray[nftContractAddress][userAddress];

        uint256[] memory nftStakedArray = new uint256[](nftStakedCollection.length());

        for (uint256 i = 0;i < nftStakedCollection.length();i++)
           nftStakedArray[i] = nftStakedCollection.at(i);

        return nftStakedArray;
    }

    // To receive MATIC from depositers when depositing NFTs
    receive() external payable {}
}


// File contracts/MasterChef.sol

// 

pragma solidity ^0.8.0;






// MasterChef is the master of Darkside. He can make Darkside and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once DARKSIDE is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract MasterChef is Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;


    // Burn address
    address constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;

    // USDC Polygon (MATIC) address
    address public constant usdcCurrencyAddress = 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174;

    // Founder 1 address
    address public constant FOUNDER1_ADDRESS = 0x3a1D1114269d7a786C154FE5278bF5b1e3e20d31;
    // Founder 2 address
    address public constant FOUNDER2_ADDRESS = 0x30139dfe2D78aFE7fb539e2F2b765d794fe52cB4;

    uint256 public totalUSDCCollected = 0;

    uint256 public accDepositUSDCRewardPerShare = 0;

    // NFTChef, the keeper of the NFTs!
    NFTChef public nftChef;
    // The CZDIAMOND TOKEN!
    CZDiamondToken public CZDiamond;
    // The DARKSIDE TOKEN!
    DarksideToken public darkside;
    // Darkside's trusty utility belt.
    DarksideToolBox public darksideToolBox;

    uint256 public darksideReleaseGradient;
    uint256 public endDarksideGradientBlock;
    uint256 public endGoalDarksideEmission;
    bool public isIncreasingGradient = false;


    // The amount of time between Rare release rate halvings.
    uint256 public czdReleaseHalfLife;
    // The inital release rate for the rare rewards period.
    uint256 public initialCZDReleaseRate;

    // Info of each user.
    struct UserInfo {
        uint256 amount;         // How many LP tokens the user has provided.
        uint256 darksideRewardDebt;     // Reward debt. See explanation below.
        uint256 CZDiamondRewardDebt;     // Reward debt. See explanation below.
        uint256 usdcRewardDebt;     // Reward debt. See explanation below.
        //
        // We do some fancy math here. Basically, any point in time, the amount of DARKSIDEs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accDarksidePerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accDarksidePerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        address lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. DARKSIDEs to distribute per block.
        uint256 lastRewardBlock;  // Last block number that DARKSIDEs distribution occurs.
        uint256 accDarksidePerShare;   // Accumulated DARKSIDEs per share, times 1e24. See below.
        uint256 accCZDiamondPerShare;   // Accumulated CZDIAMONDs per share, times 1e24. See below.
        uint256 depositFeeBPOrNFTMaticFee;      // Deposit fee in basis points
        uint256 tokenType;          // 0=Token, 1=LP Token, 2=NFT
        uint256 totalLocked;      // total units locked in the pool
    }

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block number when normal DARKSIDE mining starts.
    uint256 public startBlock;


    // The last checked balance of DARKSIDE in the burn waller
    uint256 public lastDarksideBurnBalance = 0;
    // How much of burn do CZDiamond stakers get out of 10000
    uint256 public CZDiamondShareOfBurn = 8197;

    // Darkside referral contract address.
    IDarksideReferral darksideReferral;
    // Referral commission rate in basis points.
    // This is split into 2 halves 3% for the referrer and 3% for the referee.
    uint16 public constant referralCommissionRate = 600;

    // removed to save some space..
    // uint256 public constant CZDiamondPID = 0;

    event AddPool(uint256 indexed pid, uint256 tokenType, uint256 allocPoint, address lpToken, uint256 depositFeeBPOrNFTMaticFee);
    event SetPool(uint256 indexed pid, uint256 allocPoint, uint256 depositFeeBPOrNFTMaticFee);
    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event GradientUpdated(uint256 newEndGoalDarksideEmmission, uint256 newEndDarksideEmmissionBlock);
    event SetDarksideReferral(address darksideAddress);

    constructor(
        NFTChef _nftChef,
        CZDiamondToken _CZDiamond,
        DarksideToken _darkside,
        DarksideToolBox _darksideToolBox,
        uint256 _startBlock,
        uint256 _czdReleaseHalfLife,
        uint256 _initialCZDReleaseRate,
        uint256 _beginningDarksideEmission,
        uint256 _endDarksideEmission,
        uint256 _gradient1EndBlock
    ) public {
        require(_beginningDarksideEmission < 80 ether, "too high");
        require(_endDarksideEmission < 80 ether, "too high");

        nftChef = _nftChef;
        CZDiamond = _CZDiamond;
        darkside = _darkside;
        darksideToolBox = _darksideToolBox;

        startBlock = _startBlock;

        require(_startBlock < _gradient1EndBlock + 40, "!grad");

        isIncreasingGradient = _endDarksideEmission > _beginningDarksideEmission;

        czdReleaseHalfLife = _czdReleaseHalfLife;
        initialCZDReleaseRate = _initialCZDReleaseRate;

        endDarksideGradientBlock = _gradient1EndBlock;
        endGoalDarksideEmission = _endDarksideEmission;

        darksideReleaseGradient = _darksideToolBox.calcEmissionGradient(
            _startBlock, _beginningDarksideEmission, endDarksideGradientBlock, endGoalDarksideEmission);

        add(0, 10000, address(_CZDiamond), 0, false);
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    mapping(address => bool) public poolExistence;
    modifier nonDuplicated(address _lpToken) {
        require(poolExistence[_lpToken] == false, "dup-pool");
        _;
    }

    // Add a new lp to the pool. Can only be called by the owner.
    // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
    function add(uint256 _tokenType, uint256 _allocPoint, address _lpToken, uint256 _depositFeeBPOrNFTMaticFee, bool _withUpdate) public onlyOwner nonDuplicated(_lpToken) {
        require(_tokenType == 0 || _tokenType == 1 || _tokenType == 2, "!token-type");

        // Make sure the provided token is ERC20/ERC721
        if (_tokenType == 2)
            nftChef.setPoolMaticFee(_lpToken, _depositFeeBPOrNFTMaticFee);
        else {
            ERC20(_lpToken).balanceOf(address(this));
            require(_depositFeeBPOrNFTMaticFee <= 401, "!feeBP");
        }

        if (_withUpdate) {
            massUpdatePools();
        }

        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint + _allocPoint;

        poolExistence[_lpToken] = true;

        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accDarksidePerShare: 0,
            accCZDiamondPerShare: 0,
            depositFeeBPOrNFTMaticFee: _depositFeeBPOrNFTMaticFee,
            tokenType: _tokenType,
            totalLocked: 0
        }));

        emit AddPool(poolInfo.length - 1, _tokenType, _allocPoint, address(_lpToken), _depositFeeBPOrNFTMaticFee);
    }

    // Update the given pool's DARKSIDE allocation point and deposit fee. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, uint256 _depositFeeBPOrNFTMaticFee, bool _withUpdate) external onlyOwner {
        if (poolInfo[_pid].tokenType == 2)
            nftChef.setPoolMaticFee(poolInfo[_pid].lpToken, _depositFeeBPOrNFTMaticFee);
        else
            require(_depositFeeBPOrNFTMaticFee <= 401);

        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = (totalAllocPoint - poolInfo[_pid].allocPoint) + _allocPoint;
        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBPOrNFTMaticFee = _depositFeeBPOrNFTMaticFee;
        //poolInfo[_pid].tokenType = _tokenType;
        //poolInfo[_pid].totalLocked = poolInfo[_pid].totalLocked;

        emit SetPool(_pid, _allocPoint, _depositFeeBPOrNFTMaticFee);
    }

    // View function to see pending USDCs on frontend.
    function pendingUSDC(address _user) external view returns (uint256) {
        UserInfo storage user = userInfo[0][_user];

        return ((user.amount * accDepositUSDCRewardPerShare) / (1e24)) - user.usdcRewardDebt;
    }

    // View function to see pending DARKSIDEs on frontend.
    function pendingDarkside(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accDarksidePerShare = pool.accDarksidePerShare;

        uint256 lpSupply = pool.totalLocked;
        if (block.number > pool.lastRewardBlock && lpSupply != 0 && totalAllocPoint != 0) {
            uint256 release = darksideToolBox.getDarksideRelease(isIncreasingGradient, darksideReleaseGradient, endDarksideGradientBlock, endGoalDarksideEmission, pool.lastRewardBlock, block.number);
            uint256 darksideReward = (release * pool.allocPoint) / totalAllocPoint;
            accDarksidePerShare = accDarksidePerShare + ((darksideReward * 1e24) / lpSupply);
        }
        return ((user.amount * accDarksidePerShare) / 1e24) - user.darksideRewardDebt;
    }

    // View function to see pending CZDiamond on frontend.
    function pendingCZDiamond(uint256 _pid, address _user) external view returns (uint256) {
        // CZDiamond pool never gets any more CZDiamond.
        if (_pid == 0)
            return 0;
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accCZDiamondPerShare = pool.accCZDiamondPerShare;

        uint256 lpSupply = pool.totalLocked;
        if (block.number > pool.lastRewardBlock && lpSupply != 0 && totalAllocPoint > poolInfo[0].allocPoint) {
            uint256 release = darksideToolBox.getCZDiamondRelease(initialCZDReleaseRate, czdReleaseHalfLife, pool.lastRewardBlock, block.number);
            uint256 CZDiamondReward = (release * pool.allocPoint) / (totalAllocPoint - poolInfo[0].allocPoint);
            accCZDiamondPerShare = accCZDiamondPerShare + ((CZDiamondReward * 1e24) / lpSupply);
        }

        return ((user.amount * accCZDiamondPerShare) / 1e24) - user.CZDiamondRewardDebt;
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        for (uint256 pid = 0; pid < poolInfo.length; ++pid) {
            updatePool(pid);
        }
    }

    // Transfers any excess coins gained through reflection
    // to DARKSIDE and CZDIAMOND
    function skimPool(uint256 poolId) internal {
        PoolInfo storage pool = poolInfo[poolId];
        // cannot skim any tokens we use for staking rewards.
        if (pool.tokenType == 2 || isNativeToken(address(pool.lpToken)))
            return;

        uint256 trueBalance = ERC20(pool.lpToken).balanceOf(address(this));

        uint256 skim = trueBalance > pool.totalLocked ?
                            trueBalance - pool.totalLocked :
                            0;

        if (skim > 1e4) {
            uint256 CZDiamondShare = skim / 2;
            uint256 darksideShare = skim - CZDiamondShare;
            IERC20(pool.lpToken).safeTransfer(address(CZDiamond), CZDiamondShare);
            IERC20(pool.lpToken).safeTransfer(address(darkside), darksideShare);
        }
    }

    // Updates darkside release goal and phase change duration
    function updateDarksideRelease(uint256 endBlock, uint256 endDarksideEmission) external onlyOwner {
        require(endDarksideEmission < 80 ether, "too high");
        // give some buffer as to stop extrememly large gradients
        require(block.number + 4 < endBlock, "late!");

        // this will be called infrequently
        // and deployed on a cheap gas network POLYGON (MATIC)
        massUpdatePools();

        uint256 currentDarksideEmission = darksideToolBox.getDarksideEmissionForBlock(block.number,
            isIncreasingGradient, darksideReleaseGradient, endDarksideGradientBlock, endGoalDarksideEmission);

        isIncreasingGradient = endDarksideEmission > currentDarksideEmission;
        darksideReleaseGradient = darksideToolBox.calcEmissionGradient(block.number,
            currentDarksideEmission, endBlock, endDarksideEmission);

        endDarksideGradientBlock = endBlock;
        endGoalDarksideEmission = endDarksideEmission;

        emit GradientUpdated(endGoalDarksideEmission, endDarksideGradientBlock);
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock)
            return;

        uint256 lpSupply = pool.totalLocked;
        if (lpSupply == 0 || pool.allocPoint == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }

        // CZDiamond pool is always pool 0.
        if (poolInfo[0].totalLocked > 0) {
            uint256 usdcRelease = CZDiamond.getUSDCDrip();

            accDepositUSDCRewardPerShare = accDepositUSDCRewardPerShare + ((usdcRelease * 1e24) / poolInfo[0].totalLocked);
            totalUSDCCollected = totalUSDCCollected + usdcRelease;
        }

        uint256 darksideRelease = darksideToolBox.getDarksideRelease(isIncreasingGradient, darksideReleaseGradient, endDarksideGradientBlock, endGoalDarksideEmission, pool.lastRewardBlock, block.number);
        uint256 darksideReward = (darksideRelease * pool.allocPoint) / totalAllocPoint;

        // Darkside Txn fees ONLY for CZDiamond stakers.
        if (_pid == 0) {
            uint256 burnBalance = darkside.balanceOf(BURN_ADDRESS);
            darksideReward = darksideReward + (((burnBalance - lastDarksideBurnBalance) * CZDiamondShareOfBurn) / 10000);

            lastDarksideBurnBalance = burnBalance;
        }

        darkside.mint(address(this), darksideReward);

        if (_pid != 0 && totalAllocPoint > poolInfo[0].allocPoint) {

            uint256 CZDiamondRelease = darksideToolBox.getCZDiamondRelease(initialCZDReleaseRate, czdReleaseHalfLife, pool.lastRewardBlock, block.number);

            if (CZDiamondRelease > 0) {
                uint256 CZDiamondReward = ((CZDiamondRelease * pool.allocPoint) / (totalAllocPoint - poolInfo[0].allocPoint));

                // Getting CZDiamond allocated specificlly for initial distribution.
                CZDiamondReward = CZDiamond.distribute(address(this), CZDiamondReward);

                pool.accCZDiamondPerShare = pool.accCZDiamondPerShare + ((CZDiamondReward * 1e24) / lpSupply);
            }
        }

        pool.accDarksidePerShare = pool.accDarksidePerShare + ((darksideReward * 1e24) / lpSupply);
        pool.lastRewardBlock = block.number;
    }

    // Return if address is a founder address.
    function isFounder(address addr) public pure returns (bool) {
        return addr == FOUNDER1_ADDRESS || addr == FOUNDER2_ADDRESS;
    }

    // Return if address is a founder address.
    function isNativeToken(address addr) public view returns (bool) {
        return addr == address(CZDiamond) || addr == address(darkside);
    }

    // Deposit LP tokens to MasterChef for DARKSIDE allocation.
    function deposit(uint256 _pid, uint256 _amountOrId, bool isNFTHarvest, address _referrer) external payable nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        updatePool(_pid);

        if ((pool.tokenType == 2 || _amountOrId > 0) && address(darksideReferral) != address(0) && _referrer != address(0) && _referrer != msg.sender) {
            darksideReferral.recordReferral(msg.sender, _referrer);
        }

        payPendingCZDiamondDarkside(_pid);
        if (_pid == 0)
            payPendingUSDCReward();

        if (!isNFTHarvest && pool.tokenType == 2) {
            // I don't think we need to verify we recieved the NFT as safeTransferFrom checks this sufficiently.
            nftChef.deposit{value: address(this).balance}(pool.lpToken, address(msg.sender), _amountOrId);

            user.amount = user.amount + 1;
            pool.totalLocked = pool.totalLocked + 1;
        } else if (pool.tokenType != 2 && _amountOrId > 0) {
            // Accept the balance of coins we recieve (useful for coins which take fees).
            uint256 previousBalance = ERC20(pool.lpToken).balanceOf(address(this));
            IERC20(pool.lpToken).safeTransferFrom(address(msg.sender), address(this), _amountOrId);
            _amountOrId = ERC20(pool.lpToken).balanceOf(address(this)) - previousBalance;
            require(_amountOrId > 0, "0 recieved");

            if (pool.depositFeeBPOrNFTMaticFee > 0 && !isNativeToken(address(pool.lpToken))) {
                uint256 depositFee = ((_amountOrId * pool.depositFeeBPOrNFTMaticFee) / 10000);
                // For LPs darkside handles it 100%, destroys and distributes
                uint256 darksideDepositFee = pool.tokenType == 1 ? depositFee : (depositFee / 4);
                IERC20(pool.lpToken).safeTransfer(address(darkside), darksideDepositFee);
                // darkside handles all LP type tokens
                darkside.swapDepositFeeForETH(address(pool.lpToken), pool.tokenType);

                if (pool.tokenType == 0)
                    IERC20(pool.lpToken).safeTransfer(address(CZDiamond), depositFee - darksideDepositFee);

                CZDiamond.convertDepositFeesToUSDC(address(pool.lpToken), pool.tokenType);

                user.amount = (user.amount + _amountOrId) - depositFee;
                pool.totalLocked = (pool.totalLocked + _amountOrId) - depositFee;
            } else {
                user.amount = user.amount + _amountOrId;

                pool.totalLocked = pool.totalLocked + _amountOrId;
            }
        }

        user.darksideRewardDebt = ((user.amount * pool.accDarksidePerShare) / 1e24);
        user.CZDiamondRewardDebt = ((user.amount * pool.accCZDiamondPerShare) / 1e24);

        if (_pid == 0)
            user.usdcRewardDebt = ((user.amount * accDepositUSDCRewardPerShare) / 1e24);

        skimPool(_pid);

        emit Deposit(msg.sender, _pid, _amountOrId);
    }

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amountOrId) external nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(pool.tokenType == 2 || user.amount >= _amountOrId, "!withdraw");

        require(!(_pid == 0 && isFounder(msg.sender)) || block.number > startBlock + (60 * 43200),
                "early!");

        updatePool(_pid);

        payPendingCZDiamondDarkside(_pid);
        if (_pid == 0)
            payPendingUSDCReward();

        uint256 withdrawQuantity = 0;

        if (pool.tokenType == 2) {
            nftChef.withdraw(pool.lpToken, address(msg.sender), _amountOrId);

            withdrawQuantity = 1;
        } else if (_amountOrId > 0) {
            IERC20(pool.lpToken).safeTransfer(address(msg.sender), _amountOrId);

            withdrawQuantity = _amountOrId;
        }

        user.amount = user.amount - withdrawQuantity;
        pool.totalLocked = pool.totalLocked - withdrawQuantity;

        user.darksideRewardDebt = ((user.amount * pool.accDarksidePerShare) / 1e24);
        user.CZDiamondRewardDebt = ((user.amount * pool.accCZDiamondPerShare) / 1e24);

        if (_pid == 0)
            user.usdcRewardDebt = ((user.amount * accDepositUSDCRewardPerShare) / 1e24);

        skimPool(_pid);

        emit Withdraw(msg.sender, _pid, _amountOrId);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) external nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        uint256 amount = user.amount;

        require(!(_pid == 0 && isFounder(msg.sender)) || block.number > startBlock + (60 * 43200),
                "early!");

        if (pool.tokenType == 2)
            nftChef.emergencyWithdraw(pool.lpToken, address(msg.sender));
        else
            IERC20(pool.lpToken).safeTransfer(address(msg.sender), amount);

        user.amount = 0;
        user.darksideRewardDebt = 0;
        user.CZDiamondRewardDebt = 0;
        user.usdcRewardDebt = 0;

        // In the case of an accounting error, we choose to let the user emergency withdraw anyway
        if (pool.totalLocked >=  amount)
            pool.totalLocked = pool.totalLocked - amount;
        else
            pool.totalLocked = 0;

        emit EmergencyWithdraw(msg.sender, _pid, amount);
    }

    // Pay pending DARKSIDEs & CZDIAMONDs.
    function payPendingCZDiamondDarkside(uint256 _pid) internal {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        uint256 darksidePending = ((user.amount * pool.accDarksidePerShare) / 1e24) - user.darksideRewardDebt;
        uint256 CZDiamondPending = ((user.amount * pool.accCZDiamondPerShare) / 1e24) - user.CZDiamondRewardDebt;

        if (darksidePending > 0) {
            // burn founders darkside harvest, without triggering CZD re-mint distro.
            if (isFounder(msg.sender))
                safeTokenDarksideBurn(darksidePending);
            else {
                // send rewards
                safeTokenTransfer(address(darkside), msg.sender, darksidePending);
                payReferralCommission(msg.sender, darksidePending);
            }
        }
        if (CZDiamondPending > 0) {
            // send rewards
            if (isFounder(msg.sender))
                safeTokenTransfer(address(CZDiamond), BURN_ADDRESS, CZDiamondPending);
            else
                safeTokenTransfer(address(CZDiamond), msg.sender, CZDiamondPending);
        }
    }

    // Pay pending USDC from the CZDiamond staking reward scheme.
    function payPendingUSDCReward() internal {
        UserInfo storage user = userInfo[0][msg.sender];

        uint256 usdcPending = ((user.amount * accDepositUSDCRewardPerShare) / 1e24) - user.usdcRewardDebt;

        if (usdcPending > 0) {
            // send rewards
            CZDiamond.transferUSDCToUser(msg.sender, usdcPending);
        }
    }

    // Safe token transfer function, just in case if rounding error causes pool to not have enough DARKSIDEs.
    function safeTokenDarksideBurn(uint256 _amount) internal {
        uint256 darksideBalance = darkside.balanceOf(address(this));
        if (_amount > darksideBalance) {
            darkside.burn(darksideBalance);
        } else {
            darkside.burn(_amount);
        }
    }

    // Safe token transfer function, just in case if rounding error causes pool to not have enough DARKSIDEs.
    function safeTokenTransfer(address token, address _to, uint256 _amount) internal {
        uint256 tokenBal = IERC20(token).balanceOf(address(this));
        if (_amount > tokenBal) {
            IERC20(token).safeTransfer(_to, tokenBal);
        } else {
            IERC20(token).safeTransfer(_to, _amount);
        }
    }

    // To receive MATIC from depositers when depositing NFTs
    receive() external payable {}

    // Update the darkside referral contract address by the owner
    function setDarksideReferral(IDarksideReferral _darksideReferral) external onlyOwner {
        require(address(_darksideReferral) != address(0), "!0 address");
        require(address(darksideReferral) == address(0), "!unset");
        darksideReferral = _darksideReferral;

        emit SetDarksideReferral(address(darksideReferral));
    }

    // Pay referral commission to the referrer who referred this user.
    function payReferralCommission(address _user, uint256 _pending) internal {
        if (address(darksideReferral) != address(0) && referralCommissionRate > 0) {
            address referrer = darksideReferral.getReferrer(_user);
            uint256 commissionAmount = ((_pending * referralCommissionRate) / 10000);

            if (referrer != address(0) && commissionAmount > 0) {
                darkside.mint(referrer, commissionAmount / 2);
                darkside.mint(_user, commissionAmount - (commissionAmount / 2));
                darksideReferral.recordReferralCommission(referrer, commissionAmount);
            }
        }
    }
}


// File contracts/presale/L3ArcSwap.sol

pragma solidity ^0.8.0;


contract L3ArcSwap is Ownable, ReentrancyGuard {

    address public constant feeAddress = 0x3a1D1114269d7a786C154FE5278bF5b1e3e20d31;

    address public constant arcadiumAddress = 0x3F374ed3C8e61A0d250f275609be2219005c021e;
    address public immutable preCZDiamondAddress;
    address public immutable preDarksideAddress;

    uint256 public constant arcSwapPresaleSize = 834686 * (10 ** 18);

    uint256 public preCZDiamondSaleINVPriceE35 = 1543664 * (10 ** 27);
    uint256 public preDarksideSaleINVPriceE35 = 12863864 * (10 ** 27);

    uint256 public preCZDiamondMaximumAvailable = (arcSwapPresaleSize * preCZDiamondSaleINVPriceE35) / 1e35;
    uint256 public preDarksideMaximumAvailable = (arcSwapPresaleSize * preDarksideSaleINVPriceE35) / 1e35;

    // We use a counter to defend against people sending pre{CZDiamond,Darkside} back
    uint256 public preCZDiamondRemaining = preCZDiamondMaximumAvailable;
    uint256 public preDarksideRemaining = preDarksideMaximumAvailable;

    uint256 public constant oneHourMatic = 1500;
    uint256 public constant presaleDuration = 71999;

    uint256 public startBlock;
    uint256 public endBlock = startBlock + presaleDuration;

    event PrePurchased(address sender, uint256 arcadiumSpent, uint256 preCZDiamondReceived, uint256 preDarksideReceived);
    event RetrieveDepreciatedArcTokens(address feeAddress, uint256 tokenAmount);
    event SaleINVPricesE35Changed(uint256 newCZDiamondSaleINVPriceE35, uint256 newDarksideSaleINVPriceE35);
    event StartBlockChanged(uint256 newStartBlock, uint256 newEndBlock);

    constructor(uint256 _startBlock, address _preCZDiamondAddress, address _preDarksideAddress) {
        require(block.number < _startBlock, "cannot set start block in the past!");
        require(arcadiumAddress != _preCZDiamondAddress, "arcadiumAddress cannot be equal to preCZDiamond");
        require(_preCZDiamondAddress != _preDarksideAddress, "preCZDiamond cannot be equal to preDarkside");
        require(_preCZDiamondAddress != address(0), "_preCZDiamondAddress cannot be the zero address");
        require(_preDarksideAddress != address(0), "_preDarksideAddress cannot be the zero address");

        startBlock = _startBlock;
        endBlock   = _startBlock + presaleDuration;

        preCZDiamondAddress = _preCZDiamondAddress;
        preDarksideAddress = _preDarksideAddress;
    }

    function swapArcForPresaleTokensL3(uint256 arcadiumToSwap) external nonReentrant {
        require(msg.sender != feeAddress, "fee address cannot partake in presale");
        require(block.number >= startBlock, "presale hasn't started yet, good things come to those that wait");
        require(block.number < endBlock, "presale has ended, come back next time!");
        require(preCZDiamondRemaining > 0 && preDarksideRemaining > 0, "No more presale tokens remaining! Come back next time!");
        require(IERC20(preCZDiamondAddress).balanceOf(address(this)) > 0, "No more PreCZDiamond left! Come back next time!");
        require(IERC20(preDarksideAddress).balanceOf(address(this)) > 0, "No more PreDarkside left! Come back next time!");
        require(arcadiumToSwap > 1e6, "not enough arcadium provided");

        uint256 originalPreCZDiamondAmount = (arcadiumToSwap * preCZDiamondSaleINVPriceE35) / 1e35;
        uint256 originalPreDarksideAmount = (arcadiumToSwap * preDarksideSaleINVPriceE35) / 1e35;

        uint256 preCZDiamondPurchaseAmount = originalPreCZDiamondAmount;
        uint256 preDarksidePurchaseAmount = originalPreDarksideAmount;

        // if we dont have enough left, give them the rest.
        if (preCZDiamondRemaining < preCZDiamondPurchaseAmount)
            preCZDiamondPurchaseAmount = preCZDiamondRemaining;

        if (preDarksideRemaining < preDarksidePurchaseAmount)
            preDarksidePurchaseAmount = preDarksideRemaining;


        require(preCZDiamondPurchaseAmount > 0, "user cannot purchase 0 preCZDiamond");
        require(preDarksidePurchaseAmount > 0, "user cannot purchase 0 preDarkside");

        // shouldn't be possible to fail these asserts.
        assert(preCZDiamondPurchaseAmount <= preCZDiamondRemaining);
        assert(preCZDiamondPurchaseAmount <= IERC20(preCZDiamondAddress).balanceOf(address(this)));

        assert(preDarksidePurchaseAmount <= preDarksideRemaining);
        assert(preDarksidePurchaseAmount <= IERC20(preDarksideAddress).balanceOf(address(this)));


        require(IERC20(preCZDiamondAddress).transfer(msg.sender, preCZDiamondPurchaseAmount), "failed sending preCZDiamond");
        require(IERC20(preDarksideAddress).transfer(msg.sender, preDarksidePurchaseAmount), "failed sending preDarkside");

        preCZDiamondRemaining = preCZDiamondRemaining - preCZDiamondPurchaseAmount;
        preDarksideRemaining = preDarksideRemaining - preDarksidePurchaseAmount;

        require(IERC20(arcadiumAddress).transferFrom(msg.sender, address(this), arcadiumToSwap), "failed to collect arcadium from user");

        emit PrePurchased(msg.sender, arcadiumToSwap, preCZDiamondPurchaseAmount, preDarksidePurchaseAmount);
    }


    function sendDepreciatedArcToFeeAddress() external onlyOwner {
        require(block.number > endBlock, "can only retrieve excess tokens after arcadium swap has ended");

        uint256 arcadiumInContract = IERC20(arcadiumAddress).balanceOf(address(this));

        if (arcadiumInContract > 0)
            IERC20(arcadiumAddress).transfer(feeAddress, arcadiumInContract);

        emit RetrieveDepreciatedArcTokens(feeAddress, arcadiumInContract);
    }

    function setSaleINVPriceE35(uint256 _newPreCZDiamondSaleINVPriceE35, uint256 _newPreDarksideSaleINVPriceE35) external onlyOwner {
        require(block.number < startBlock - (oneHourMatic * 4), "cannot change price 4 hours before start block");
        require(_newPreCZDiamondSaleINVPriceE35 >= 1 * (10 ** 32), "new CZD price is to high!");
        require(_newPreCZDiamondSaleINVPriceE35 <= 1 * (10 ** 34), "new CZD price is too low!");

        require(_newPreDarksideSaleINVPriceE35 >= 9 * (10 ** 32), "new Darkside price is to high!");
        require(_newPreDarksideSaleINVPriceE35 <= 9 * (10 ** 34), "new Darkside price is too low!");

        preCZDiamondSaleINVPriceE35 = _newPreCZDiamondSaleINVPriceE35;
        preDarksideSaleINVPriceE35 = _newPreDarksideSaleINVPriceE35;

        preCZDiamondMaximumAvailable = (arcSwapPresaleSize * preCZDiamondSaleINVPriceE35) / 1e35;
        preDarksideMaximumAvailable  = (arcSwapPresaleSize * preDarksideSaleINVPriceE35) / 1e35;

        preCZDiamondRemaining = preCZDiamondMaximumAvailable;
        preDarksideRemaining = preDarksideMaximumAvailable;

        emit SaleINVPricesE35Changed(preCZDiamondSaleINVPriceE35, preDarksideSaleINVPriceE35);
    }

    function setStartBlock(uint256 _newStartBlock) external onlyOwner {
        require(block.number < startBlock, "cannot change start block if sale has already commenced");
        require(block.number < _newStartBlock, "cannot set start block in the past");
        startBlock = _newStartBlock;
        endBlock   = _newStartBlock + presaleDuration;

        emit StartBlockChanged(_newStartBlock, endBlock);
    }
}


// File contracts/presale/L3MFSwap.sol

pragma solidity ^0.8.0;


contract L3MFSwap is Ownable, ReentrancyGuard {

    address public constant feeAddress = 0x3a1D1114269d7a786C154FE5278bF5b1e3e20d31;

    address public constant myFriendsAddress = 0xa509Da749745Ac07E9Ae47E7a092eAd2648B47f2;
    address public immutable preCZDiamondAddress;
    address public immutable preDarksideAddress;

    uint256 public constant mfSwapPresaleSize = 66800 * (10 ** 18);

    uint256 public preCZDiamondSaleINVPriceE35 = 25621640 * (10 ** 27);
    uint256 public preDarksideSaleINVPriceE35 = 213513666 * (10 ** 27);

    uint256 public preCZDiamondMaximumAvailable = (mfSwapPresaleSize * preCZDiamondSaleINVPriceE35) / 1e35;
    uint256 public preDarksideMaximumAvailable = (mfSwapPresaleSize * preDarksideSaleINVPriceE35) / 1e35;

    // We use a counter to defend against people sending pre{CZDiamond,Darkside} back
    uint256 public preCZDiamondRemaining = preCZDiamondMaximumAvailable;
    uint256 public preDarksideRemaining = preDarksideMaximumAvailable;

    uint256 public constant oneHourMatic = 1500;
    uint256 public constant presaleDuration = 71999;

    uint256 public startBlock;
    uint256 public endBlock = startBlock + presaleDuration;

    event PrePurchased(address sender, uint256 myFriendsSpent, uint256 preCZDiamondReceived, uint256 preDarksideReceived);
    event RetrieveDepreciatedMFTokens(address feeAddress, uint256 tokenAmount);
    event SaleINVPricesE35Changed(uint256 newCZDiamondSaleINVPriceE35, uint256 newDarksideSaleINVPriceE35);
    event StartBlockChanged(uint256 newStartBlock, uint256 newEndBlock);

    constructor(uint256 _startBlock, address _preCZDiamondAddress, address _preDarksideAddress) {
        require(block.number < _startBlock, "cannot set start block in the past!");
        require(myFriendsAddress != _preCZDiamondAddress, "myFriendsAddress cannot be equal to preCZDiamond");
        require(_preCZDiamondAddress != _preDarksideAddress, "preCZDiamond cannot be equal to preDarkside");
        require(_preCZDiamondAddress != address(0), "_preCZDiamondAddress cannot be the zero address");
        require(_preDarksideAddress != address(0), "_preDarksideAddress cannot be the zero address");

        startBlock = _startBlock;
        endBlock   = _startBlock + presaleDuration;

        preCZDiamondAddress = _preCZDiamondAddress;
        preDarksideAddress = _preDarksideAddress;
    }

    function swapMFForPresaleTokensL3(uint256 myFriendsToSwap) external nonReentrant {
        require(msg.sender != feeAddress, "fee address cannot partake in presale");
        require(block.number >= startBlock, "presale hasn't started yet, good things come to those that wait");
        require(block.number < endBlock, "presale has ended, come back next time!");
        require(preCZDiamondRemaining > 0 && preDarksideRemaining > 0, "No more presale tokens remaining! Come back next time!");
        require(IERC20(preCZDiamondAddress).balanceOf(address(this)) > 0, "No more PreCZDiamond left! Come back next time!");
        require(IERC20(preDarksideAddress).balanceOf(address(this)) > 0, "No more PreDarkside left! Come back next time!");
        require(myFriendsToSwap > 1e6, "not enough MyFriends provided");

        uint256 originalPreCZDiamondAmount = (myFriendsToSwap * preCZDiamondSaleINVPriceE35) / 1e35;
        uint256 originalPreDarksideAmount = (myFriendsToSwap * preDarksideSaleINVPriceE35) / 1e35;

        uint256 preCZDiamondPurchaseAmount = originalPreCZDiamondAmount;
        uint256 preDarksidePurchaseAmount = originalPreDarksideAmount;

        // if we dont have enough left, give them the rest.
        if (preCZDiamondRemaining < preCZDiamondPurchaseAmount)
            preCZDiamondPurchaseAmount = preCZDiamondRemaining;

        if (preDarksideRemaining < preDarksidePurchaseAmount)
            preDarksidePurchaseAmount = preDarksideRemaining;


        require(preCZDiamondPurchaseAmount > 0, "user cannot purchase 0 preCZDiamond");
        require(preDarksidePurchaseAmount > 0, "user cannot purchase 0 preDarkside");

        // shouldn't be possible to fail these asserts.
        assert(preCZDiamondPurchaseAmount <= preCZDiamondRemaining);
        assert(preCZDiamondPurchaseAmount <= IERC20(preCZDiamondAddress).balanceOf(address(this)));

        assert(preDarksidePurchaseAmount <= preDarksideRemaining);
        assert(preDarksidePurchaseAmount <= IERC20(preDarksideAddress).balanceOf(address(this)));


        require(IERC20(preCZDiamondAddress).transfer(msg.sender, preCZDiamondPurchaseAmount), "failed sending preCZDiamond");
        require(IERC20(preDarksideAddress).transfer(msg.sender, preDarksidePurchaseAmount), "failed sending preDarkside");

        preCZDiamondRemaining = preCZDiamondRemaining - preCZDiamondPurchaseAmount;
        preDarksideRemaining = preDarksideRemaining - preDarksidePurchaseAmount;

        require(IERC20(myFriendsAddress).transferFrom(msg.sender, address(this), myFriendsToSwap), "failed to collect myFriends from user");

        emit PrePurchased(msg.sender, myFriendsToSwap, preCZDiamondPurchaseAmount, preDarksidePurchaseAmount);
    }


    function sendDepreciatedMFToFeeAddress() external onlyOwner {
        require(block.number > endBlock, "can only retrieve excess tokens after myfriends swap has ended");

        uint256 myFriendsInContract = IERC20(myFriendsAddress).balanceOf(address(this));

        if (myFriendsInContract > 0)
            IERC20(myFriendsAddress).transfer(feeAddress, myFriendsInContract);

        emit RetrieveDepreciatedMFTokens(feeAddress, myFriendsInContract);
    }

    function setSaleINVPriceE35(uint256 _newPreCZDiamondSaleINVPriceE35, uint256 _newPreDarksideSaleINVPriceE35) external onlyOwner {
        require(block.number < startBlock - (oneHourMatic * 4), "cannot change price 4 hours before start block");
        require(_newPreCZDiamondSaleINVPriceE35 >= 2 * (10 ** 33), "new myfriends price is to high!");
        require(_newPreCZDiamondSaleINVPriceE35 <= 28 * (10 ** 34), "new myfriends price is too low!");

        require(_newPreDarksideSaleINVPriceE35 >= 2 * (10 ** 34), "new darkside price is to high!");
        require(_newPreDarksideSaleINVPriceE35 <= 23 * (10 ** 35), "new darkside price is too low!");

        preCZDiamondSaleINVPriceE35 = _newPreCZDiamondSaleINVPriceE35;
        preDarksideSaleINVPriceE35 = _newPreDarksideSaleINVPriceE35;

        preCZDiamondMaximumAvailable = (mfSwapPresaleSize * preCZDiamondSaleINVPriceE35) / 1e35;
        preDarksideMaximumAvailable  = (mfSwapPresaleSize * preDarksideSaleINVPriceE35) / 1e35;

        preCZDiamondRemaining = preCZDiamondMaximumAvailable;
        preDarksideRemaining = preDarksideMaximumAvailable;

        emit SaleINVPricesE35Changed(preCZDiamondSaleINVPriceE35, preDarksideSaleINVPriceE35);
    }

    function setStartBlock(uint256 _newStartBlock) external onlyOwner {
        require(block.number < startBlock, "cannot change start block if sale has already commenced");
        require(block.number < _newStartBlock, "cannot set start block in the past");
        startBlock = _newStartBlock;
        endBlock   = _newStartBlock + presaleDuration;

        emit StartBlockChanged(_newStartBlock, endBlock);
    }
}


// File contracts/presale/L3TokenRedeem.sol

pragma solidity ^0.8.0;



contract L3TokenRedeem is Ownable, ReentrancyGuard {

    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;

    address public constant feeAddress = 0x3a1D1114269d7a786C154FE5278bF5b1e3e20d31;

    address public immutable preCZDiamond;
    address public immutable preDarksideAddress;

    address public immutable CZDiamondAddress;
    address public immutable darksideAddress;

    L3ArcSwap public immutable l3ArcSwap;
    L3MFSwap public immutable l3MFSwap;

    uint256 public startBlock;

    bool public hasRetrievedUnsoldPresale = false;

    event CZDiamondSwap(address sender, uint256 amount);
    event DarksideSwap(address sender, uint256 amount);
    event RetrieveUnclaimedTokens(uint256 CZDiamondAmount, uint256 Darksidemount);
    event StartBlockChanged(uint256 newStartBlock);

    constructor(uint256 _startBlock, L3ArcSwap _l3ArcSwap, L3MFSwap _l3MFSwap, address _preCZDiamondAddress, address _preDarksideAddress, address _CZDiamondAddress, address _darksideAddress) {
        require(block.number < _startBlock, "cannot set start block in the past!");
        require(_preCZDiamondAddress != _preDarksideAddress, "preCZDiamond cannot be equal to preDarkside");
        require(_CZDiamondAddress != _darksideAddress, "preCZDiamond cannot be equal to preDarkside");
        require(_preCZDiamondAddress != address(0), "_preCZDiamondAddress cannot be the zero address");
        require(_CZDiamondAddress != address(0), "_CZDiamondAddress cannot be the zero address");

        startBlock = _startBlock;

        l3ArcSwap = _l3ArcSwap;
        l3MFSwap = _l3MFSwap;

        preCZDiamond = _preCZDiamondAddress;
        preDarksideAddress = _preDarksideAddress;
        CZDiamondAddress = _CZDiamondAddress;
        darksideAddress = _darksideAddress;
    }

    function swapPreCZDiamondForCZDiamond(uint256 CZDiamondSwapAmount) external nonReentrant {
        require(block.number >= startBlock, "token redemption hasn't started yet, good things come to those that wait");
        require(IERC20(CZDiamondAddress).balanceOf(address(this)) >= CZDiamondSwapAmount, "Not Enough tokens in contract for swap");

        IERC20(preCZDiamond).transferFrom(msg.sender, BURN_ADDRESS, CZDiamondSwapAmount);
        IERC20(CZDiamondAddress).transfer(msg.sender, CZDiamondSwapAmount);

        emit CZDiamondSwap(msg.sender, CZDiamondSwapAmount);
    }

    function swapPreDarksideForDarkside(uint256 darksideSwapAmount) external nonReentrant {
        require(block.number >= startBlock, "token redemption hasn't started yet, good things come to those that wait");
        require(IERC20(darksideAddress).balanceOf(address(this)) >= darksideSwapAmount, "Not Enough tokens in contract for swap");

        IERC20(preDarksideAddress).transferFrom(msg.sender, BURN_ADDRESS, darksideSwapAmount);
        IERC20(darksideAddress).transfer(msg.sender, darksideSwapAmount);

        emit DarksideSwap(msg.sender, darksideSwapAmount);
    }

    function sendUnclaimedsToFeeAddress() external onlyOwner {
        require(block.number > l3ArcSwap.endBlock(), "can only retrieve excess tokens after arc swap has ended");
        require(block.number > l3MFSwap.endBlock(), "can only retrieve excess tokens after myfriends swap has ended");
        require(!hasRetrievedUnsoldPresale, "can only burn unsold presale once!");

        uint256 wastedPreCZDiamondTokend = l3ArcSwap.preCZDiamondRemaining() + l3MFSwap.preCZDiamondRemaining();
        uint256 wastedPreDarksideTokens = l3ArcSwap.preDarksideRemaining() + l3MFSwap.preDarksideRemaining();

        require(wastedPreCZDiamondTokend <= IERC20(CZDiamondAddress).balanceOf(address(this)),
            "retreiving too much preCZDiamond, has this been setup properly?");

        require(wastedPreDarksideTokens <= IERC20(darksideAddress).balanceOf(address(this)),
            "retreiving too much preDarkside, has this been setup properly?");

        if (wastedPreCZDiamondTokend > 0)
            IERC20(CZDiamondAddress).transfer(feeAddress, wastedPreCZDiamondTokend);

        if (wastedPreDarksideTokens > 0)
            IERC20(darksideAddress).transfer(feeAddress, wastedPreDarksideTokens);

        hasRetrievedUnsoldPresale = true;

        emit RetrieveUnclaimedTokens(wastedPreCZDiamondTokend, wastedPreDarksideTokens);
    }

    function setStartBlock(uint256 _newStartBlock) external onlyOwner {
        require(block.number < startBlock, "cannot change start block if sale has already commenced");
        require(block.number < _newStartBlock, "cannot set start block in the past");
        startBlock = _newStartBlock;

        emit StartBlockChanged(_newStartBlock);
    }
}


// File contracts/presale/PreCZDiamond.sol

pragma solidity ^0.8.0;


// PreCZDiamond
contract PreCZDiamond is ERC20('PCZDIAMOND', 'PCZDIAMOND') {
    constructor() {
        _mint(address(0x3a1D1114269d7a786C154FE5278bF5b1e3e20d31), uint256(30000 * (10 ** 18)));
    }
}


// File contracts/presale/PreDarkside.sol

pragma solidity ^0.8.0;


// PreDarkside
contract PreDarkside is ERC20('PDARKCOIN', 'PDARK') {
    constructor() {
        _mint(address(0x3a1D1114269d7a786C154FE5278bF5b1e3e20d31), uint256(250000 * (10 ** 18)));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract NFTChef","name":"_nftChef","type":"address"},{"internalType":"contract CZDiamondToken","name":"_CZDiamond","type":"address"},{"internalType":"contract DarksideToken","name":"_darkside","type":"address"},{"internalType":"contract DarksideToolBox","name":"_darksideToolBox","type":"address"},{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"uint256","name":"_czdReleaseHalfLife","type":"uint256"},{"internalType":"uint256","name":"_initialCZDReleaseRate","type":"uint256"},{"internalType":"uint256","name":"_beginningDarksideEmission","type":"uint256"},{"internalType":"uint256","name":"_endDarksideEmission","type":"uint256"},{"internalType":"uint256","name":"_gradient1EndBlock","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokenType","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":false,"internalType":"address","name":"lpToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"depositFeeBPOrNFTMaticFee","type":"uint256"}],"name":"AddPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newEndGoalDarksideEmmission","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newEndDarksideEmmissionBlock","type":"uint256"}],"name":"GradientUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"darksideAddress","type":"address"}],"name":"SetDarksideReferral","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"depositFeeBPOrNFTMaticFee","type":"uint256"}],"name":"SetPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"CZDiamond","outputs":[{"internalType":"contract CZDiamondToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CZDiamondShareOfBurn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FOUNDER1_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FOUNDER2_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"accDepositUSDCRewardPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenType","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"address","name":"_lpToken","type":"address"},{"internalType":"uint256","name":"_depositFeeBPOrNFTMaticFee","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"czdReleaseHalfLife","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"darkside","outputs":[{"internalType":"contract DarksideToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"darksideReleaseGradient","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"darksideToolBox","outputs":[{"internalType":"contract DarksideToolBox","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amountOrId","type":"uint256"},{"internalType":"bool","name":"isNFTHarvest","type":"bool"},{"internalType":"address","name":"_referrer","type":"address"}],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"endDarksideGradientBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endGoalDarksideEmission","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialCZDReleaseRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"isFounder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"isIncreasingGradient","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"isNativeToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastDarksideBurnBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nftChef","outputs":[{"internalType":"contract NFTChef","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingCZDiamond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingDarkside","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"pendingUSDC","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"poolExistence","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"address","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accDarksidePerShare","type":"uint256"},{"internalType":"uint256","name":"accCZDiamondPerShare","type":"uint256"},{"internalType":"uint256","name":"depositFeeBPOrNFTMaticFee","type":"uint256"},{"internalType":"uint256","name":"tokenType","type":"uint256"},{"internalType":"uint256","name":"totalLocked","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"referralCommissionRate","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint256","name":"_depositFeeBPOrNFTMaticFee","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IDarksideReferral","name":"_darksideReferral","type":"address"}],"name":"setDarksideReferral","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalUSDCCollected","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"endBlock","type":"uint256"},{"internalType":"uint256","name":"endDarksideEmission","type":"uint256"}],"name":"updateDarksideRelease","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"usdcCurrencyAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"darksideRewardDebt","type":"uint256"},{"internalType":"uint256","name":"CZDiamondRewardDebt","type":"uint256"},{"internalType":"uint256","name":"usdcRewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amountOrId","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000c211604399dd68534eb31d0df7cfdd198e4c55380000000000000000000000006664c64c8582e62da861fcac33a627b0f92ff0f80000000000000000000000001942b8262a0683b54f4f91d0c08ddd92ed6e8fe6000000000000000000000000c5673e4fe49378529401ca416eed321b894157c6000000000000000000000000000000000000000000000000000000000120b24000000000000000000000000000000000000000000000000000000000001312d0000000000000000000000000000000000000000000000000003abd95dcb7600000000000000000000000000000000000000000000000000170bb9a39e22100000000000000000000000000000000000000000000000000000b10392d1ef10000000000000000000000000000000000000000000000000000000000000120b2d6

-----Decoded View---------------
Arg [0] : _nftChef (address): 0xc211604399dD68534eb31d0Df7CFDd198E4c5538
Arg [1] : _CZDiamond (address): 0x6664C64C8582e62dA861Fcac33a627b0f92fF0F8
Arg [2] : _darkside (address): 0x1942b8262a0683B54f4f91D0c08dDD92ed6E8FE6
Arg [3] : _darksideToolBox (address): 0xc5673e4fE49378529401ca416eed321b894157c6
Arg [4] : _startBlock (uint256): 18920000
Arg [5] : _czdReleaseHalfLife (uint256): 1250000
Arg [6] : _initialCZDReleaseRate (uint256): 16534000000000000
Arg [7] : _beginningDarksideEmission (uint256): 26570000000000000000
Arg [8] : _endDarksideEmission (uint256): 797200000000000000
Arg [9] : _gradient1EndBlock (uint256): 18920150

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 000000000000000000000000c211604399dd68534eb31d0df7cfdd198e4c5538
Arg [1] : 0000000000000000000000006664c64c8582e62da861fcac33a627b0f92ff0f8
Arg [2] : 0000000000000000000000001942b8262a0683b54f4f91d0c08ddd92ed6e8fe6
Arg [3] : 000000000000000000000000c5673e4fe49378529401ca416eed321b894157c6
Arg [4] : 000000000000000000000000000000000000000000000000000000000120b240
Arg [5] : 00000000000000000000000000000000000000000000000000000000001312d0
Arg [6] : 000000000000000000000000000000000000000000000000003abd95dcb76000
Arg [7] : 00000000000000000000000000000000000000000000000170bb9a39e2210000
Arg [8] : 0000000000000000000000000000000000000000000000000b10392d1ef10000
Arg [9] : 000000000000000000000000000000000000000000000000000000000120b2d6

195178:25560:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;219656:347;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;196013:29;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;201279:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;198333:26;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;;;198574:34;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;211396:3032;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;211178:145;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;205305:994;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;196272:40;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;196089:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;214480:1413;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;198676:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;195534:85;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;198776:42;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;208654:2274;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;215964:1004;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;198888:42;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;201728:1335;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;206382:146;;;;;;;;;;;;;:::i;:::-;;195411:88;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6016:94;;;;;;;;;;;;;:::i;:::-;;204058:226;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;195746:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;196181:39;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;195792:47;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;203179:815;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;195652:85;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5365:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;207509:1069;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;198415:64;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;195889:22;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;195947:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;196227:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;210984:138;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;201382:45;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;196136:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;196487:36;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;199154:51;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;204352:885;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6265:192;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;196386:33;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;219656:347;5596:12;:10;:12::i;:::-;5585:23;;:7;:5;:7::i;:::-;:23;;;5577:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;219798:1:::1;219760:40;;219768:17;219760:40;;;;219752:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;219871:1;219834:39;;219842:16;;;;;;;;;;;219834:39;;;219826:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;219914:17;219895:16;;:36;;;;;;;;;;;;;;;;;;219949:46;219977:16;;;;;;;;;;;219949:46;;;;;;:::i;:::-;;;;;;;;219656:347:::0;:::o;196013:29::-;;;;;;;;;;;;;:::o;201279:95::-;201324:7;201351:8;:15;;;;201344:22;;201279:95;:::o;198333:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;198574:34::-;;;;:::o;211396:3032::-;64573:1;65169:7;;:19;;65161:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;64573:1;65302:7;:18;;;;211527:21:::1;211551:8;211560:4;211551:14;;;;;;;;;;;;;;;;;;;;;;;;;;211527:38;;211576:21;211600:8;:14;211609:4;211600:14;;;;;;;;;;;:26;211615:10;211600:26;;;;;;;;;;;;;;;211576:50;;211639:16;211650:4;211639:10;:16::i;:::-;211691:1;211673:4;:14;;;:19;:38;;;;211710:1;211696:11;:15;211673:38;211672:83;;;;;211753:1;211716:39;;211724:16;;;;;;;;;;;211716:39;;;;211672:83;:110;;;;;211780:1;211759:23;;:9;:23;;;;211672:110;:137;;;;;211799:10;211786:23;;:9;:23;;;;211672:137;211668:224;;;211826:16;;;;;;;;;;;:31;;;211858:10;211870:9;211826:54;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;211668:224;211904:33;211932:4;211904:27;:33::i;:::-;211960:1;211952:4;:9;211948:50;;;211976:22;:20;:22::i;:::-;211948:50;212016:12;212015:13;:36;;;;;212050:1;212032:4;:14;;;:19;212015:36;212011:2035;;;212182:7;;;;;;;;;;;:15;;;212205:21;212228:4;:12;;;;;;;;;;;;212250:10;212263:11;212182:93;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;212320:1;212306:4;:11;;;:15;;;;:::i;:::-;212292:4;:11;;:29;;;;212374:1;212355:4;:16;;;:20;;;;:::i;:::-;212336:4;:16;;:39;;;;212011:2035;;;212415:1;212397:4;:14;;;:19;;:38;;;;;212434:1;212420:11;:15;212397:38;212393:1653;;;212543:23;212575:4;:12;;;;;;;;;;;;212569:29;;;212607:4;212569:44;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;212543:70;;212628:86;212674:10;212695:4;212702:11;212635:4;:12;;;;;;;;;;;;212628:37;;;;:86;;;;;;:::i;:::-;212790:15;212749:4;:12;;;;;;;;;;;;212743:29;;;212781:4;212743:44;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:62;;;;:::i;:::-;212729:76;;212842:1;212828:11;:15;212820:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;212912:1;212879:4;:30;;;:34;:75;;;;;212918:36;212940:4;:12;;;;;;;;;;;;212918:13;:36::i;:::-;212917:37;212879:75;212875:1160;;;212975:18;213046:5;213012:4;:30;;;212998:11;:44;;;;:::i;:::-;212997:54;;;;:::i;:::-;212975:77;;213150:26;213197:1;213179:4;:14;;;:19;:51;;213228:1;213215:10;:14;;;;:::i;:::-;213179:51;;;213201:10;213179:51;213150:80;;213249:72;213291:8;;;;;;;;;;;213302:18;213256:4;:12;;;;;;;;;;;;213249:33;;;;:72;;;;;:::i;:::-;213396:8;;;;;;;;;;;:29;;;213434:4;:12;;;;;;;;;;;;213449:4;:14;;;213396:68;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;213507:1;213489:4;:14;;;:19;213485:132;;;213531:86;213573:9;;;;;;;;;;;213598:18;213585:10;:31;;;;:::i;:::-;213538:4;:12;;;;;;;;;;;;213531:33;;;;:86;;;;;:::i;:::-;213485:132;213638:9;;;;;;;;;;;:34;;;213681:4;:12;;;;;;;;;;;;213696:4;:14;;;213638:73;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;213776:10;213761:11;213747:4;:11;;;:25;;;;:::i;:::-;213746:40;;;;:::i;:::-;213732:4;:11;;:54;;;;213859:10;213844:11;213825:4;:16;;;:30;;;;:::i;:::-;213824:45;;;;:::i;:::-;213805:4;:16;;:64;;;;212875:1160;;;;;213938:11;213924:4;:11;;;:25;;;;:::i;:::-;213910:4;:11;;:39;;;;214008:11;213989:4;:16;;;:30;;;;:::i;:::-;213970:4;:16;;:49;;;;212875:1160;212393:1653;;212011:2035;214128:4;214100;:24;;;214086:4;:11;;;:38;;;;:::i;:::-;214085:47;;;;:::i;:::-;214058:4;:23;;:75;;;;214216:4;214187;:25;;;214173:4;:11;;;:39;;;;:::i;:::-;214172:48;;;;:::i;:::-;214144:4;:24;;:77;;;;214246:1;214238:4;:9;214234:103;;;214332:4;214300:28;;214286:4;:11;;;:42;;;;:::i;:::-;214285:51;;;;:::i;:::-;214262:4;:19;;:75;;;;214234:103;214350:14;214359:4;214350:8;:14::i;:::-;214402:4;214390:10;214382:38;;;214408:11;214382:38;;;;;;:::i;:::-;;;;;;;;65333:1;;64529::::0;65481:7;:22;;;;211396:3032;;;;:::o;211178:145::-;211236:4;211276:9;;;;;;;;;;;211260:26;;:4;:26;;;:55;;;;211306:8;;;;;;;;;;;211290:25;;:4;:25;;;211260:55;211253:62;;211178:145;;;:::o;205305:994::-;205383:7;205473:1;205465:4;:9;205461:36;;;205496:1;205489:8;;;;205461:36;205508:21;205532:8;205541:4;205532:14;;;;;;;;;;;;;;;;;;;;;;;;;;205508:38;;205557:21;205581:8;:14;205590:4;205581:14;;;;;;;;;;;:21;205596:5;205581:21;;;;;;;;;;;;;;;205557:45;;205613:28;205644:4;:25;;;205613:56;;205682:16;205701:4;:16;;;205682:35;;205747:4;:20;;;205732:12;:35;:52;;;;;205783:1;205771:8;:13;;205732:52;:96;;;;;205806:8;205815:1;205806:11;;;;;;;;;;;;;;;;;;;;;;;;;;:22;;;205788:15;;:40;205732:96;205728:472;;;205845:15;205863;;;;;;;;;;;:35;;;205899:21;;205922:18;;205942:4;:20;;;205964:12;205863:114;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;205845:132;;205992:23;206067:8;206076:1;206067:11;;;;;;;;;;;;;;;;;;;;;;;;;;:22;;;206049:15;;:40;;;;:::i;:::-;206029:4;:15;;;206019:7;:25;;;;:::i;:::-;206018:72;;;;:::i;:::-;205992:98;;206179:8;206171:4;206153:15;:22;;;;:::i;:::-;206152:35;;;;:::i;:::-;206128:20;:60;;;;:::i;:::-;206105:83;;205728:472;;;206267:4;:24;;;206259:4;206235:20;206221:4;:11;;;:34;;;;:::i;:::-;206220:43;;;;:::i;:::-;206219:72;;;;:::i;:::-;206212:79;;;;;;205305:994;;;;;:::o;196272:40::-;;;;;;;;;;;;;:::o;196089:38::-;;;;;;;;;;;;;:::o;214480:1413::-;64573:1;65169:7;;:19;;65161:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;64573:1;65302:7;:18;;;;214566:21:::1;214590:8;214599:4;214590:14;;;;;;;;;;;;;;;;;;;;;;;;;;214566:38;;214615:21;214639:8;:14;214648:4;214639:14;;;;;;;;;;;:26;214654:10;214639:26;;;;;;;;;;;;;;;214615:50;;214702:1;214684:4;:14;;;:19;:49;;;;214722:11;214707:4;:11;;;:26;;214684:49;214676:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;214778:1;214770:4;:9;:34;;;;;214783:21;214793:10;214783:9;:21::i;:::-;214770:34;214768:37;:81;;;;214838:10;214824;;:25;;;;:::i;:::-;214809:12;:40;214768:81;214760:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;214890:16;214901:4;214890:10;:16::i;:::-;214919:33;214947:4;214919:27;:33::i;:::-;214975:1;214967:4;:9;214963:50;;;214991:22;:20;:22::i;:::-;214963:50;215026:24;215089:1;215071:4;:14;;;:19;215067:321;;;215107:7;;;;;;;;;;;:16;;;215124:4;:12;;;;;;;;;;;;215146:10;215159:11;215107:64;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;215207:1;215188:20;;215067:321;;;215244:1;215230:11;:15;215226:162;;;215262:67;215304:10;215317:11;215269:4;:12;;;;;;;;;;;;215262:33;;;;:67;;;;;:::i;:::-;215365:11;215346:30;;215226:162;215067:321;215428:16;215414:4;:11;;;:30;;;;:::i;:::-;215400:4;:11;;:44;;;;215493:16;215474:4;:16;;;:35;;;;:::i;:::-;215455:4;:16;;:54;;;;215592:4;215564;:24;;;215550:4;:11;;;:38;;;;:::i;:::-;215549:47;;;;:::i;:::-;215522:4;:23;;:75;;;;215680:4;215651;:25;;;215637:4;:11;;;:39;;;;:::i;:::-;215636:48;;;;:::i;:::-;215608:4;:24;;:77;;;;215710:1;215702:4;:9;215698:103;;;215796:4;215764:28;;215750:4;:11;;;:42;;;;:::i;:::-;215749:51;;;;:::i;:::-;215726:4;:19;;:75;;;;215698:103;215814:14;215823:4;215814:8;:14::i;:::-;215867:4;215855:10;215846:39;;;215873:11;215846:39;;;;;;:::i;:::-;;;;;;;;65333:1;;;64529::::0;65481:7;:22;;;;214480:1413;;:::o;198676:25::-;;;;:::o;195534:85::-;195577:42;195534:85;:::o;198776:42::-;;;;:::o;208654:2274::-;208706:21;208730:8;208739:4;208730:14;;;;;;;;;;;;;;;;;;;;;;;;;;208706:38;;208775:4;:20;;;208759:12;:36;208755:62;;208810:7;;;208755:62;208829:16;208848:4;:16;;;208829:35;;208891:1;208879:8;:13;:37;;;;208915:1;208896:4;:15;;;:20;208879:37;208875:126;;;208956:12;208933:4;:20;;:35;;;;208983:7;;;;208875:126;209088:1;209062:8;209071:1;209062:11;;;;;;;;;;;;;;;;;;;;;;;;;;:23;;;:27;209058:300;;;209106:19;209128:9;;;;;;;;;;;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;209106:45;;209254:8;209263:1;209254:11;;;;;;;;;;;;;;;;;;;;;;;;;;:23;;;209246:4;209232:11;:18;;;;:::i;:::-;209231:46;;;;:::i;:::-;209199:28;;:79;;;;:::i;:::-;209168:28;:110;;;;209335:11;209314:18;;:32;;;;:::i;:::-;209293:18;:53;;;;209058:300;;209370:23;209396:15;;;;;;;;;;;:34;;;209431:20;;;;;;;;;;;209453:23;;209478:24;;209504:23;;209529:4;:20;;;209551:12;209396:168;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;209370:194;;209575:22;209638:15;;209619:4;:15;;;209601;:33;;;;:::i;:::-;209600:53;;;;:::i;:::-;209575:78;;209736:1;209728:4;:9;209724:273;;;209754:19;209776:8;;;;;;;;;;;:18;;;195323:42;209776:32;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;209754:54;;209925:5;209901:20;;209874:23;;209860:11;:37;;;;:::i;:::-;209859:62;;;;:::i;:::-;209858:72;;;;:::i;:::-;209840:14;:91;;;;:::i;:::-;209823:108;;209974:11;209948:23;:37;;;;209724:273;;210009:8;;;;;;;;;;;:13;;;210031:4;210038:14;210009:44;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;210078:1;210070:4;:9;;:53;;;;;210101:8;210110:1;210101:11;;;;;;;;;;;;;;;;;;;;;;;;;;:22;;;210083:15;;:40;210070:53;210066:706;;;210142:24;210169:15;;;;;;;;;;;:35;;;210205:21;;210228:18;;210248:4;:20;;;210270:12;210169:114;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;210142:141;;210323:1;210304:16;:20;210300:461;;;210345:23;210430:8;210439:1;210430:11;;;;;;;;;;;;;;;;;;;;;;;;;;:22;;;210412:15;;:40;;;;:::i;:::-;210392:4;:15;;;210373:16;:34;;;;:::i;:::-;210372:81;;;;:::i;:::-;210345:109;;210579:9;;;;;;;;;;;:20;;;210608:4;210615:15;210579:52;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;210561:70;;210736:8;210728:4;210710:15;:22;;;;:::i;:::-;210709:35;;;;:::i;:::-;210680:4;:25;;;:65;;;;:::i;:::-;210652:4;:25;;:93;;;;210300:461;;210066:706;;210865:8;210857:4;210840:14;:21;;;;:::i;:::-;210839:34;;;;:::i;:::-;210811:4;:24;;;:63;;;;:::i;:::-;210784:4;:24;;:90;;;;210908:12;210885:4;:20;;:35;;;;208654:2274;;;;;;:::o;215964:1004::-;64573:1;65169:7;;:19;;65161:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;64573:1;65302:7;:18;;;;216038:21:::1;216062:8;216071:4;216062:14;;;;;;;;;;;;;;;;;;;;;;;;;;216038:38;;216087:21;216111:8;:14;216120:4;216111:14;;;;;;;;;;;:26;216126:10;216111:26;;;;;;;;;;;;;;;216087:50;;216148:14;216165:4;:11;;;216148:28;;216207:1;216199:4;:9;:34;;;;;216212:21;216222:10;216212:9;:21::i;:::-;216199:34;216197:37;:81;;;;216267:10;216253;;:25;;;;:::i;:::-;216238:12;:40;216197:81;216189:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;216341:1;216323:4;:14;;;:19;216319:189;;;216357:7;;;;;;;;;;;:25;;;216383:4;:12;;;;;;;;;;;;216405:10;216357:60;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;216319:189;;;216446:62;216488:10;216501:6;216453:4;:12;;;;;;;;;;;;216446:33;;;;:62;;;;;:::i;:::-;216319:189;216535:1;216521:4;:11;;:15;;;;216573:1;216547:4;:23;;:27;;;;216612:1;216585:4;:24;;:28;;;;216646:1;216624:4;:19;;:23;;;;216785:6;216764:4;:16;;;:27;216760:139;;216844:6;216825:4;:16;;;:25;;;;:::i;:::-;216806:4;:16;;:44;;;;216760:139;;;216898:1;216879:4;:16;;:20;;;;216760:139;216947:4;216935:10;216917:43;;;216953:6;216917:43;;;;;;:::i;:::-;;;;;;;;65333:1;;;64529::::0;65481:7;:22;;;;215964:1004;:::o;198888:42::-;;;;:::o;201728:1335::-;5596:12;:10;:12::i;:::-;5585:23;;:7;:5;:7::i;:::-;:23;;;5577:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;201885:8:::1;201521:5;201494:32;;:13;:23;201508:8;201494:23;;;;;;;;;;;;;;;;;;;;;;;;;:32;;;201486:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;201928:1:::2;201914:10;:15;:34;;;;201947:1;201933:10;:15;201914:34;:53;;;;201966:1;201952:10;:15;201914:53;201906:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;202071:1;202057:10;:15;202053:245;;;202087:7;;;;;;;;;;;:23;;;202111:8;202121:26;202087:61;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;202053:245;;;202185:8;202179:25;;;202213:4;202179:40;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;202272:3;202242:26;:33;;202234:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;202053:245;202314:11;202310:61;;;202342:17;:15;:17::i;:::-;202310:61;202383:23;202424:10;;202409:12;:25;:53;;202452:10;;202409:53;;;202437:12;202409:53;202383:79;;202509:11;202491:15;;:29;;;;:::i;:::-;202473:15;:47;;;;202559:4;202533:13;:23;202547:8;202533:23;;;;;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;202576:8;202590:346;;;;;;;;202623:8;202590:346;;;;;;202658:11;202590:346;;;;202701:15;202590:346;;;;202752:1;202590:346;;;;202790:1;202590:346;;;;202833:26;202590:346;;;;202885:10;202590:346;;;;202923:1;202590:346;;::::0;202576:361:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;202981:1;202963:8;:15;;;;:19;;;;:::i;:::-;202955:100;202984:10;202996:11;203017:8;203028:26;202955:100;;;;;;;;;:::i;:::-;;;;;;;;201550:1;5656::::1;201728:1335:::0;;;;;:::o;206382:146::-;206432:11;206427:94;206455:8;:15;;;;206449:3;:21;206427:94;;;206494:15;206505:3;206494:10;:15::i;:::-;206472:5;;;;:::i;:::-;;;206427:94;;;;206382:146::o;195411:88::-;195457:42;195411:88;:::o;6016:94::-;5596:12;:10;:12::i;:::-;5585:23;;:7;:5;:7::i;:::-;:23;;;5577:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;6081:21:::1;6099:1;6081:9;:21::i;:::-;6016:94::o:0;204058:226::-;204117:7;204137:21;204161:8;:11;204170:1;204161:11;;;;;;;;;;;:18;204173:5;204161:18;;;;;;;;;;;;;;;204137:42;;204257:4;:19;;;204248:4;204215:28;;204201:4;:11;;;:42;;;;:::i;:::-;204200:53;;;;:::i;:::-;204199:77;;;;:::i;:::-;204192:84;;;204058:226;;;:::o;195746:37::-;;;;:::o;196181:39::-;;;;:::o;195792:47::-;;;;:::o;203179:815::-;5596:12;:10;:12::i;:::-;5585:23;;:7;:5;:7::i;:::-;:23;;;5577:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;203343:1:::1;203315:8;203324:4;203315:14;;;;;;;;;;;;;;;;;;;;;;;;;;:24;;;:29;203311:194;;;203359:7;;;;;;;;;;;:23;;;203383:8;203392:4;203383:14;;;;;;;;;;;;;;;;;;;;;;;;;;:22;;;;;;;;;;;;203407:26;203359:75;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;203311:194;;;203501:3;203471:26;:33;;203463:42;;;::::0;::::1;;203311:194;203522:11;203518:61;;;203550:17;:15;:17::i;:::-;203518:61;203655:11;203626:8;203635:4;203626:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;;203608:15;;:43;;;;:::i;:::-;203607:59;;;;:::i;:::-;203589:15;:77;;;;203705:11;203677:8;203686:4;203677:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;:39;;;;203770:26;203727:8;203736:4;203727:14;;;;;;;;;;;;;;;;;;;;;;;;;;:40;;:69;;;;203940:4;203932:54;203946:11;203959:26;203932:54;;;;;;;:::i;:::-;;;;;;;;203179:815:::0;;;;:::o;195652:85::-;195695:42;195652:85;:::o;5365:87::-;5411:7;5438:6;;;;;;;;;;;5431:13;;5365:87;:::o;207509:1069::-;5596:12;:10;:12::i;:::-;5585:23;;:7;:5;:7::i;:::-;:23;;;5577:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;207647:8:::1;207625:19;:30;207617:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;207773:8;207769:1;207754:12;:16;;;;:::i;:::-;:27;207746:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;207913:17;:15;:17::i;:::-;207943:31;207977:15;;;;;;;;;;;:43;;;208021:12;208048:20;;;;;;;;;;;208070:23;;208095:24;;208121:23;;207977:168;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;207943:202;;208203:23;208181:19;:45;208158:20;;:68;;;;;;;;;;;;;;;;;;208263:15;;;;;;;;;;;:36;;;208300:12;208327:23;208352:8;208362:19;208263:119;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;208237:23;:145;;;;208422:8;208395:24;:35;;;;208467:19;208441:23;:45;;;;208504:66;208520:23;;208545:24;;208504:66;;;;;;;:::i;:::-;;;;;;;;5656:1;207509:1069:::0;;:::o;198415:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;195889:22::-;;;;;;;;;;;;;:::o;195947:31::-;;;;;;;;;;;;;:::o;196227:38::-;;;;:::o;210984:138::-;211038:4;195577:42;211062:24;;:4;:24;;;:52;;;;195695:42;211090:24;;:4;:24;;;211062:52;211055:59;;210984:138;;;:::o;201382:45::-;;;;;;;;;;;;;;;;;;;;;;:::o;196136:38::-;;;;:::o;196487:36::-;;;;:::o;199154:51::-;199202:3;199154:51;:::o;204352:885::-;204429:7;204449:21;204473:8;204482:4;204473:14;;;;;;;;;;;;;;;;;;;;;;;;;;204449:38;;204498:21;204522:8;:14;204531:4;204522:14;;;;;;;;;;;:21;204537:5;204522:21;;;;;;;;;;;;;;;204498:45;;204554:27;204584:4;:24;;;204554:54;;204621:16;204640:4;:16;;;204621:35;;204686:4;:20;;;204671:12;:35;:52;;;;;204722:1;204710:8;:13;;204671:52;:76;;;;;204746:1;204727:15;;:20;;204671:76;204667:475;;;204764:15;204782;;;;;;;;;;;:34;;;204817:20;;;;;;;;;;;204839:23;;204864:24;;204890:23;;204915:4;:20;;;204937:12;204782:168;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;204764:186;;204965:22;205020:15;;205001:4;:15;;;204991:7;:25;;;;:::i;:::-;204990:45;;;;:::i;:::-;204965:70;;205121:8;205113:4;205096:14;:21;;;;:::i;:::-;205095:34;;;;:::i;:::-;205072:19;:58;;;;:::i;:::-;205050:80;;204667:475;;;205206:4;:23;;;205198:4;205175:19;205161:4;:11;;;:33;;;;:::i;:::-;205160:42;;;;:::i;:::-;205159:70;;;;:::i;:::-;205152:77;;;;;;204352:885;;;;:::o;6265:192::-;5596:12;:10;:12::i;:::-;5585:23;;:7;:5;:7::i;:::-;:23;;;5577:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;6374:1:::1;6354:22;;:8;:22;;;;6346:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;6430:19;6440:8;6430:9;:19::i;:::-;6265:192:::0;:::o;196386:33::-;;;;:::o;4144:98::-;4197:7;4224:10;4217:17;;4144:98;:::o;217020:1170::-;217091:21;217115:8;217124:4;217115:14;;;;;;;;;;;;;;;;;;;;;;;;;;217091:38;;217140:21;217164:8;:14;217173:4;217164:14;;;;;;;;;;;:26;217179:10;217164:26;;;;;;;;;;;;;;;217140:50;;217203:23;217281:4;:23;;;217273:4;217245;:24;;;217231:4;:11;;;:38;;;;:::i;:::-;217230:47;;;;:::i;:::-;217229:75;;;;:::i;:::-;217203:101;;217315:24;217395:4;:24;;;217387:4;217358;:25;;;217344:4;:11;;;:39;;;;:::i;:::-;217343:48;;;;:::i;:::-;217342:77;;;;:::i;:::-;217315:104;;217454:1;217436:15;:19;217432:442;;;217563:21;217573:10;217563:9;:21::i;:::-;217559:304;;;217603:38;217625:15;217603:21;:38::i;:::-;217559:304;;;217713:65;217739:8;;;;;;;;;;;217750:10;217762:15;217713:17;:65::i;:::-;217797:50;217819:10;217831:15;217797:21;:50::i;:::-;217559:304;217432:442;217907:1;217888:16;:20;217884:299;;;217958:21;217968:10;217958:9;:21::i;:::-;217954:217;;;217998:69;218024:9;;;;;;;;;;;195323:42;218050:16;217998:17;:69::i;:::-;217954:217;;;218104:67;218130:9;;;;;;;;;;;218142:10;218154:16;218104:17;:67::i;:::-;217954:217;217884:299;217020:1170;;;;;:::o;218265:359::-;218317:21;218341:8;:11;218350:1;218341:11;;;;;;;;;;;:23;218353:10;218341:23;;;;;;;;;;;;;;;218317:47;;218377:19;218455:4;:19;;;218447:4;218415:28;;218401:4;:11;;;:42;;;;:::i;:::-;218400:51;;;;:::i;:::-;218399:75;;;;:::i;:::-;218377:97;;218505:1;218491:11;:15;218487:130;;;218552:9;;;;;;;;;;;:28;;;218581:10;218593:11;218552:53;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;218487:130;218265:359;;:::o;56842:248::-;56986:96;57006:5;57036:27;;;57065:4;57071:2;57075:5;57013:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56986:19;:96::i;:::-;56842:248;;;;:::o;56623:211::-;56740:86;56760:5;56790:23;;;56815:2;56819:5;56767:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56740:19;:86::i;:::-;56623:211;;;:::o;206631:806::-;206685:21;206709:8;206718:6;206709:16;;;;;;;;;;;;;;;;;;;;;;;;;;206685:40;;206821:1;206803:4;:14;;;:19;:59;;;;206826:36;206848:4;:12;;;;;;;;;;;;206826:13;:36::i;:::-;206803:59;206799:85;;;206877:7;;;206799:85;206896:19;206924:4;:12;;;;;;;;;;;;206918:29;;;206956:4;206918:44;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;206896:66;;206975:12;207004:4;:16;;;206990:11;:30;:125;;207114:1;206990:125;;;207066:4;:16;;;207052:11;:30;;;;:::i;:::-;206990:125;206975:140;;207139:3;207132:4;:10;207128:302;;;207159:22;207191:1;207184:4;:8;;;;:::i;:::-;207159:33;;207207:21;207238:14;207231:4;:21;;;;:::i;:::-;207207:45;;207267:69;207309:9;;;;;;;;;;;207321:14;207274:4;:12;;;;;;;;;;;;207267:33;;;;:69;;;;;:::i;:::-;207351:67;207393:8;;;;;;;;;;;207404:13;207358:4;:12;;;;;;;;;;;;207351:33;;;;:67;;;;;:::i;:::-;207128:302;;;206631:806;;;;;:::o;6465:173::-;6521:16;6540:6;;;;;;;;;;;6521:25;;6566:8;6557:6;;:17;;;;;;;;;;;;;;;;;;6621:8;6590:40;;6611:8;6590:40;;;;;;;;;;;;6465:173;;:::o;218743:288::-;218811:23;218837:8;;;;;;;;;;;:18;;;218864:4;218837:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;218811:59;;218895:15;218885:7;:25;218881:143;;;218927:8;;;;;;;;;;;:13;;;218941:15;218927:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;218881:143;;;218990:8;;;;;;;;;;;:13;;;219004:7;218990:22;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;218881:143;218743:288;;:::o;219150:332::-;219242:16;219268:5;219261:23;;;219293:4;219261:38;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;219242:57;;219324:8;219314:7;:18;219310:165;;;219349:41;219376:3;219381:8;219356:5;219349:26;;;;:41;;;;;:::i;:::-;219310:165;;;219423:40;219450:3;219455:7;219430:5;219423:26;;;;:40;;;;;:::i;:::-;219310:165;219150:332;;;;:::o;220083:652::-;220208:1;220171:39;;220179:16;;;;;;;;;;;220171:39;;;;:69;;;;;220239:1;199202:3;220214:26;;;220171:69;220167:561;;;220257:16;220276;;;;;;;;;;;:28;;;220305:5;220276:35;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;220257:54;;220326:24;220392:5;199202:3;220355:33;;:8;:33;;;;:::i;:::-;220354:43;;;;:::i;:::-;220326:72;;220439:1;220419:22;;:8;:22;;;;:46;;;;;220464:1;220445:16;:20;220419:46;220415:302;;;220486:8;;;;;;;;;;;:13;;;220500:8;220529:1;220510:16;:20;;;;:::i;:::-;220486:45;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;220550:8;;;;;;;;;;;:13;;;220564:5;220610:1;220591:16;:20;;;;:::i;:::-;220571:16;:41;;;;:::i;:::-;220550:63;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;220632:16;;;;;;;;;;;:41;;;220674:8;220684:16;220632:69;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;220415:302;220167:561;;;220083:652;;:::o;59196:716::-;59620:23;59646:69;59674:4;59646:69;;;;;;;;;;;;;;;;;59654:5;59646:27;;;;:69;;;;;:::i;:::-;59620:95;;59750:1;59730:10;:17;:21;59726:179;;;59827:10;59816:30;;;;;;;;;;;;:::i;:::-;59808:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;59726:179;59196:716;;;:::o;51711:229::-;51848:12;51880:52;51902:6;51910:4;51916:1;51919:12;51880:21;:52::i;:::-;51873:59;;51711:229;;;;;:::o;52831:511::-;53001:12;53059:5;53034:21;:30;;53026:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;53126:18;53137:6;53126:10;:18::i;:::-;53118:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;53192:12;53206:23;53233:6;:11;;53252:5;53259:4;53233:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53191:73;;;;53282:52;53300:7;53309:10;53321:12;53282:17;:52::i;:::-;53275:59;;;;52831:511;;;;;;:::o;48905:387::-;48965:4;49173:12;49240:7;49228:20;49220:28;;49283:1;49276:4;:8;49269:15;;;48905:387;;;:::o;55300:712::-;55450:12;55479:7;55475:530;;;55510:10;55503:17;;;;55475:530;55644:1;55624:10;:17;:21;55620:374;;;55822:10;55816:17;55883:15;55870:10;55866:2;55862:19;55855:44;55770:148;55965:12;55958:20;;;;;;;;;;;:::i;:::-;;;;;;;;55300:712;;;;;;:::o;7:139:1:-;;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;152:143::-;;240:6;234:13;225:22;;256:33;283:5;256:33;:::i;:::-;215:80;;;;:::o;301:133::-;;382:6;369:20;360:29;;398:30;422:5;398:30;:::i;:::-;350:84;;;;:::o;440:137::-;;525:6;519:13;510:22;;541:30;565:5;541:30;:::i;:::-;500:77;;;;:::o;583:191::-;;693:6;680:20;671:29;;709:59;762:5;709:59;:::i;:::-;661:113;;;;:::o;780:139::-;;864:6;851:20;842:29;;880:33;907:5;880:33;:::i;:::-;832:87;;;;:::o;925:143::-;;1013:6;1007:13;998:22;;1029:33;1056:5;1029:33;:::i;:::-;988:80;;;;:::o;1074:262::-;;1182:2;1170:9;1161:7;1157:23;1153:32;1150:2;;;1198:1;1195;1188:12;1150:2;1241:1;1266:53;1311:7;1302:6;1291:9;1287:22;1266:53;:::i;:::-;1256:63;;1212:117;1140:196;;;;:::o;1342:284::-;;1461:2;1449:9;1440:7;1436:23;1432:32;1429:2;;;1477:1;1474;1467:12;1429:2;1520:1;1545:64;1601:7;1592:6;1581:9;1577:22;1545:64;:::i;:::-;1535:74;;1491:128;1419:207;;;;:::o;1632:278::-;;1748:2;1736:9;1727:7;1723:23;1719:32;1716:2;;;1764:1;1761;1754:12;1716:2;1807:1;1832:61;1885:7;1876:6;1865:9;1861:22;1832:61;:::i;:::-;1822:71;;1778:125;1706:204;;;;:::o;1916:314::-;;2050:2;2038:9;2029:7;2025:23;2021:32;2018:2;;;2066:1;2063;2056:12;2018:2;2109:1;2134:79;2205:7;2196:6;2185:9;2181:22;2134:79;:::i;:::-;2124:89;;2080:143;2008:222;;;;:::o;2236:262::-;;2344:2;2332:9;2323:7;2319:23;2315:32;2312:2;;;2360:1;2357;2350:12;2312:2;2403:1;2428:53;2473:7;2464:6;2453:9;2449:22;2428:53;:::i;:::-;2418:63;;2374:117;2302:196;;;;:::o;2504:284::-;;2623:2;2611:9;2602:7;2598:23;2594:32;2591:2;;;2639:1;2636;2629:12;2591:2;2682:1;2707:64;2763:7;2754:6;2743:9;2739:22;2707:64;:::i;:::-;2697:74;;2653:128;2581:207;;;;:::o;2794:407::-;;;2919:2;2907:9;2898:7;2894:23;2890:32;2887:2;;;2935:1;2932;2925:12;2887:2;2978:1;3003:53;3048:7;3039:6;3028:9;3024:22;3003:53;:::i;:::-;2993:63;;2949:117;3105:2;3131:53;3176:7;3167:6;3156:9;3152:22;3131:53;:::i;:::-;3121:63;;3076:118;2877:324;;;;;:::o;3207:407::-;;;3332:2;3320:9;3311:7;3307:23;3303:32;3300:2;;;3348:1;3345;3338:12;3300:2;3391:1;3416:53;3461:7;3452:6;3441:9;3437:22;3416:53;:::i;:::-;3406:63;;3362:117;3518:2;3544:53;3589:7;3580:6;3569:9;3565:22;3544:53;:::i;:::-;3534:63;;3489:118;3290:324;;;;;:::o;3620:838::-;;;;;;3793:3;3781:9;3772:7;3768:23;3764:33;3761:2;;;3810:1;3807;3800:12;3761:2;3853:1;3878:53;3923:7;3914:6;3903:9;3899:22;3878:53;:::i;:::-;3868:63;;3824:117;3980:2;4006:53;4051:7;4042:6;4031:9;4027:22;4006:53;:::i;:::-;3996:63;;3951:118;4108:2;4134:53;4179:7;4170:6;4159:9;4155:22;4134:53;:::i;:::-;4124:63;;4079:118;4236:2;4262:53;4307:7;4298:6;4287:9;4283:22;4262:53;:::i;:::-;4252:63;;4207:118;4364:3;4391:50;4433:7;4424:6;4413:9;4409:22;4391:50;:::i;:::-;4381:60;;4335:116;3751:707;;;;;;;;:::o;4464:692::-;;;;;4620:3;4608:9;4599:7;4595:23;4591:33;4588:2;;;4637:1;4634;4627:12;4588:2;4680:1;4705:53;4750:7;4741:6;4730:9;4726:22;4705:53;:::i;:::-;4695:63;;4651:117;4807:2;4833:53;4878:7;4869:6;4858:9;4854:22;4833:53;:::i;:::-;4823:63;;4778:118;4935:2;4961:50;5003:7;4994:6;4983:9;4979:22;4961:50;:::i;:::-;4951:60;;4906:115;5060:2;5086:53;5131:7;5122:6;5111:9;5107:22;5086:53;:::i;:::-;5076:63;;5031:118;4578:578;;;;;;;:::o;5162:692::-;;;;;5318:3;5306:9;5297:7;5293:23;5289:33;5286:2;;;5335:1;5332;5325:12;5286:2;5378:1;5403:53;5448:7;5439:6;5428:9;5424:22;5403:53;:::i;:::-;5393:63;;5349:117;5505:2;5531:53;5576:7;5567:6;5556:9;5552:22;5531:53;:::i;:::-;5521:63;;5476:118;5633:2;5659:53;5704:7;5695:6;5684:9;5680:22;5659:53;:::i;:::-;5649:63;;5604:118;5761:2;5787:50;5829:7;5820:6;5809:9;5805:22;5787:50;:::i;:::-;5777:60;;5732:115;5276:578;;;;;;;:::o;5860:118::-;5947:24;5965:5;5947:24;:::i;:::-;5942:3;5935:37;5925:53;;:::o;5984:109::-;6065:21;6080:5;6065:21;:::i;:::-;6060:3;6053:34;6043:50;;:::o;6099:373::-;;6231:38;6263:5;6231:38;:::i;:::-;6285:88;6366:6;6361:3;6285:88;:::i;:::-;6278:95;;6382:52;6427:6;6422:3;6415:4;6408:5;6404:16;6382:52;:::i;:::-;6459:6;6454:3;6450:16;6443:23;;6207:265;;;;;:::o;6478:193::-;6596:68;6658:5;6596:68;:::i;:::-;6591:3;6584:81;6574:97;;:::o;6677:191::-;6794:67;6855:5;6794:67;:::i;:::-;6789:3;6782:80;6772:96;;:::o;6874:179::-;6985:61;7040:5;6985:61;:::i;:::-;6980:3;6973:74;6963:90;;:::o;7059:181::-;7171:62;7227:5;7171:62;:::i;:::-;7166:3;7159:75;7149:91;;:::o;7246:364::-;;7362:39;7395:5;7362:39;:::i;:::-;7417:71;7481:6;7476:3;7417:71;:::i;:::-;7410:78;;7497:52;7542:6;7537:3;7530:4;7523:5;7519:16;7497:52;:::i;:::-;7574:29;7596:6;7574:29;:::i;:::-;7569:3;7565:39;7558:46;;7338:272;;;;;:::o;7616:365::-;;7779:66;7843:1;7838:3;7779:66;:::i;:::-;7772:73;;7854:93;7943:3;7854:93;:::i;:::-;7972:2;7967:3;7963:12;7956:19;;7762:219;;;:::o;7987:366::-;;8150:67;8214:2;8209:3;8150:67;:::i;:::-;8143:74;;8226:93;8315:3;8226:93;:::i;:::-;8344:2;8339:3;8335:12;8328:19;;8133:220;;;:::o;8359:365::-;;8522:66;8586:1;8581:3;8522:66;:::i;:::-;8515:73;;8597:93;8686:3;8597:93;:::i;:::-;8715:2;8710:3;8706:12;8699:19;;8505:219;;;:::o;8730:365::-;;8893:66;8957:1;8952:3;8893:66;:::i;:::-;8886:73;;8968:93;9057:3;8968:93;:::i;:::-;9086:2;9081:3;9077:12;9070:19;;8876:219;;;:::o;9101:366::-;;9264:67;9328:2;9323:3;9264:67;:::i;:::-;9257:74;;9340:93;9429:3;9340:93;:::i;:::-;9458:2;9453:3;9449:12;9442:19;;9247:220;;;:::o;9473:366::-;;9636:67;9700:2;9695:3;9636:67;:::i;:::-;9629:74;;9712:93;9801:3;9712:93;:::i;:::-;9830:2;9825:3;9821:12;9814:19;;9619:220;;;:::o;9845:365::-;;10008:66;10072:1;10067:3;10008:66;:::i;:::-;10001:73;;10083:93;10172:3;10083:93;:::i;:::-;10201:2;10196:3;10192:12;10185:19;;9991:219;;;:::o;10216:365::-;;10379:66;10443:1;10438:3;10379:66;:::i;:::-;10372:73;;10454:93;10543:3;10454:93;:::i;:::-;10572:2;10567:3;10563:12;10556:19;;10362:219;;;:::o;10587:365::-;;10750:66;10814:1;10809:3;10750:66;:::i;:::-;10743:73;;10825:93;10914:3;10825:93;:::i;:::-;10943:2;10938:3;10934:12;10927:19;;10733:219;;;:::o;10958:366::-;;11121:67;11185:2;11180:3;11121:67;:::i;:::-;11114:74;;11197:93;11286:3;11197:93;:::i;:::-;11315:2;11310:3;11306:12;11299:19;;11104:220;;;:::o;11330:366::-;;11493:67;11557:2;11552:3;11493:67;:::i;:::-;11486:74;;11569:93;11658:3;11569:93;:::i;:::-;11687:2;11682:3;11678:12;11671:19;;11476:220;;;:::o;11702:366::-;;11865:67;11929:2;11924:3;11865:67;:::i;:::-;11858:74;;11941:93;12030:3;11941:93;:::i;:::-;12059:2;12054:3;12050:12;12043:19;;11848:220;;;:::o;12074:366::-;;12237:67;12301:2;12296:3;12237:67;:::i;:::-;12230:74;;12313:93;12402:3;12313:93;:::i;:::-;12431:2;12426:3;12422:12;12415:19;;12220:220;;;:::o;12446:365::-;;12609:66;12673:1;12668:3;12609:66;:::i;:::-;12602:73;;12684:93;12773:3;12684:93;:::i;:::-;12802:2;12797:3;12793:12;12786:19;;12592:219;;;:::o;12817:366::-;;12980:67;13044:2;13039:3;12980:67;:::i;:::-;12973:74;;13056:93;13145:3;13056:93;:::i;:::-;13174:2;13169:3;13165:12;13158:19;;12963:220;;;:::o;13189:366::-;;13352:67;13416:2;13411:3;13352:67;:::i;:::-;13345:74;;13428:93;13517:3;13428:93;:::i;:::-;13546:2;13541:3;13537:12;13530:19;;13335:220;;;:::o;13561:115::-;13646:23;13663:5;13646:23;:::i;:::-;13641:3;13634:36;13624:52;;:::o;13682:118::-;13769:24;13787:5;13769:24;:::i;:::-;13764:3;13757:37;13747:53;;:::o;13806:271::-;;13958:93;14047:3;14038:6;13958:93;:::i;:::-;13951:100;;14068:3;14061:10;;13940:137;;;;:::o;14083:222::-;;14214:2;14203:9;14199:18;14191:26;;14227:71;14295:1;14284:9;14280:17;14271:6;14227:71;:::i;:::-;14181:124;;;;:::o;14311:332::-;;14470:2;14459:9;14455:18;14447:26;;14483:71;14551:1;14540:9;14536:17;14527:6;14483:71;:::i;:::-;14564:72;14632:2;14621:9;14617:18;14608:6;14564:72;:::i;:::-;14437:206;;;;;:::o;14649:442::-;;14836:2;14825:9;14821:18;14813:26;;14849:71;14917:1;14906:9;14902:17;14893:6;14849:71;:::i;:::-;14930:72;14998:2;14987:9;14983:18;14974:6;14930:72;:::i;:::-;15012;15080:2;15069:9;15065:18;15056:6;15012:72;:::i;:::-;14803:288;;;;;;:::o;15097:332::-;;15256:2;15245:9;15241:18;15233:26;;15269:71;15337:1;15326:9;15322:17;15313:6;15269:71;:::i;:::-;15350:72;15418:2;15407:9;15403:18;15394:6;15350:72;:::i;:::-;15223:206;;;;;:::o;15435:997::-;;15762:3;15751:9;15747:19;15739:27;;15776:71;15844:1;15833:9;15829:17;15820:6;15776:71;:::i;:::-;15857:72;15925:2;15914:9;15910:18;15901:6;15857:72;:::i;:::-;15939;16007:2;15996:9;15992:18;15983:6;15939:72;:::i;:::-;16021;16089:2;16078:9;16074:18;16065:6;16021:72;:::i;:::-;16103:73;16171:3;16160:9;16156:19;16147:6;16103:73;:::i;:::-;16186;16254:3;16243:9;16239:19;16230:6;16186:73;:::i;:::-;16269;16337:3;16326:9;16322:19;16313:6;16269:73;:::i;:::-;16352;16420:3;16409:9;16405:19;16396:6;16352:73;:::i;:::-;15729:703;;;;;;;;;;;:::o;16438:210::-;;16563:2;16552:9;16548:18;16540:26;;16576:65;16638:1;16627:9;16623:17;16614:6;16576:65;:::i;:::-;16530:118;;;;:::o;16654:763::-;;16919:3;16908:9;16904:19;16896:27;;16933:65;16995:1;16984:9;16980:17;16971:6;16933:65;:::i;:::-;17008:72;17076:2;17065:9;17061:18;17052:6;17008:72;:::i;:::-;17090;17158:2;17147:9;17143:18;17134:6;17090:72;:::i;:::-;17172;17240:2;17229:9;17225:18;17216:6;17172:72;:::i;:::-;17254:73;17322:3;17311:9;17307:19;17298:6;17254:73;:::i;:::-;17337;17405:3;17394:9;17390:19;17381:6;17337:73;:::i;:::-;16886:531;;;;;;;;;:::o;17423:284::-;;17585:2;17574:9;17570:18;17562:26;;17598:102;17697:1;17686:9;17682:17;17673:6;17598:102;:::i;:::-;17552:155;;;;:::o;17713:282::-;;17874:2;17863:9;17859:18;17851:26;;17887:101;17985:1;17974:9;17970:17;17961:6;17887:101;:::i;:::-;17841:154;;;;:::o;18001:270::-;;18156:2;18145:9;18141:18;18133:26;;18169:95;18261:1;18250:9;18246:17;18237:6;18169:95;:::i;:::-;18123:148;;;;:::o;18277:272::-;;18433:2;18422:9;18418:18;18410:26;;18446:96;18539:1;18528:9;18524:17;18515:6;18446:96;:::i;:::-;18400:149;;;;:::o;18555:313::-;;18706:2;18695:9;18691:18;18683:26;;18755:9;18749:4;18745:20;18741:1;18730:9;18726:17;18719:47;18783:78;18856:4;18847:6;18783:78;:::i;:::-;18775:86;;18673:195;;;;:::o;18874:419::-;;19078:2;19067:9;19063:18;19055:26;;19127:9;19121:4;19117:20;19113:1;19102:9;19098:17;19091:47;19155:131;19281:4;19155:131;:::i;:::-;19147:139;;19045:248;;;:::o;19299:419::-;;19503:2;19492:9;19488:18;19480:26;;19552:9;19546:4;19542:20;19538:1;19527:9;19523:17;19516:47;19580:131;19706:4;19580:131;:::i;:::-;19572:139;;19470:248;;;:::o;19724:419::-;;19928:2;19917:9;19913:18;19905:26;;19977:9;19971:4;19967:20;19963:1;19952:9;19948:17;19941:47;20005:131;20131:4;20005:131;:::i;:::-;19997:139;;19895:248;;;:::o;20149:419::-;;20353:2;20342:9;20338:18;20330:26;;20402:9;20396:4;20392:20;20388:1;20377:9;20373:17;20366:47;20430:131;20556:4;20430:131;:::i;:::-;20422:139;;20320:248;;;:::o;20574:419::-;;20778:2;20767:9;20763:18;20755:26;;20827:9;20821:4;20817:20;20813:1;20802:9;20798:17;20791:47;20855:131;20981:4;20855:131;:::i;:::-;20847:139;;20745:248;;;:::o;20999:419::-;;21203:2;21192:9;21188:18;21180:26;;21252:9;21246:4;21242:20;21238:1;21227:9;21223:17;21216:47;21280:131;21406:4;21280:131;:::i;:::-;21272:139;;21170:248;;;:::o;21424:419::-;;21628:2;21617:9;21613:18;21605:26;;21677:9;21671:4;21667:20;21663:1;21652:9;21648:17;21641:47;21705:131;21831:4;21705:131;:::i;:::-;21697:139;;21595:248;;;:::o;21849:419::-;;22053:2;22042:9;22038:18;22030:26;;22102:9;22096:4;22092:20;22088:1;22077:9;22073:17;22066:47;22130:131;22256:4;22130:131;:::i;:::-;22122:139;;22020:248;;;:::o;22274:419::-;;22478:2;22467:9;22463:18;22455:26;;22527:9;22521:4;22517:20;22513:1;22502:9;22498:17;22491:47;22555:131;22681:4;22555:131;:::i;:::-;22547:139;;22445:248;;;:::o;22699:419::-;;22903:2;22892:9;22888:18;22880:26;;22952:9;22946:4;22942:20;22938:1;22927:9;22923:17;22916:47;22980:131;23106:4;22980:131;:::i;:::-;22972:139;;22870:248;;;:::o;23124:419::-;;23328:2;23317:9;23313:18;23305:26;;23377:9;23371:4;23367:20;23363:1;23352:9;23348:17;23341:47;23405:131;23531:4;23405:131;:::i;:::-;23397:139;;23295:248;;;:::o;23549:419::-;;23753:2;23742:9;23738:18;23730:26;;23802:9;23796:4;23792:20;23788:1;23777:9;23773:17;23766:47;23830:131;23956:4;23830:131;:::i;:::-;23822:139;;23720:248;;;:::o;23974:419::-;;24178:2;24167:9;24163:18;24155:26;;24227:9;24221:4;24217:20;24213:1;24202:9;24198:17;24191:47;24255:131;24381:4;24255:131;:::i;:::-;24247:139;;24145:248;;;:::o;24399:419::-;;24603:2;24592:9;24588:18;24580:26;;24652:9;24646:4;24642:20;24638:1;24627:9;24623:17;24616:47;24680:131;24806:4;24680:131;:::i;:::-;24672:139;;24570:248;;;:::o;24824:419::-;;25028:2;25017:9;25013:18;25005:26;;25077:9;25071:4;25067:20;25063:1;25052:9;25048:17;25041:47;25105:131;25231:4;25105:131;:::i;:::-;25097:139;;24995:248;;;:::o;25249:419::-;;25453:2;25442:9;25438:18;25430:26;;25502:9;25496:4;25492:20;25488:1;25477:9;25473:17;25466:47;25530:131;25656:4;25530:131;:::i;:::-;25522:139;;25420:248;;;:::o;25674:218::-;;25803:2;25792:9;25788:18;25780:26;;25816:69;25882:1;25871:9;25867:17;25858:6;25816:69;:::i;:::-;25770:122;;;;:::o;25898:222::-;;26029:2;26018:9;26014:18;26006:26;;26042:71;26110:1;26099:9;26095:17;26086:6;26042:71;:::i;:::-;25996:124;;;;:::o;26126:652::-;;26363:3;26352:9;26348:19;26340:27;;26377:71;26445:1;26434:9;26430:17;26421:6;26377:71;:::i;:::-;26458:66;26520:2;26509:9;26505:18;26496:6;26458:66;:::i;:::-;26534:72;26602:2;26591:9;26587:18;26578:6;26534:72;:::i;:::-;26616;26684:2;26673:9;26669:18;26660:6;26616:72;:::i;:::-;26698:73;26766:3;26755:9;26751:19;26742:6;26698:73;:::i;:::-;26330:448;;;;;;;;:::o;26784:332::-;;26943:2;26932:9;26928:18;26920:26;;26956:71;27024:1;27013:9;27009:17;27000:6;26956:71;:::i;:::-;27037:72;27105:2;27094:9;27090:18;27081:6;27037:72;:::i;:::-;26910:206;;;;;:::o;27122:553::-;;27337:3;27326:9;27322:19;27314:27;;27351:71;27419:1;27408:9;27404:17;27395:6;27351:71;:::i;:::-;27432:72;27500:2;27489:9;27485:18;27476:6;27432:72;:::i;:::-;27514;27582:2;27571:9;27567:18;27558:6;27514:72;:::i;:::-;27596;27664:2;27653:9;27649:18;27640:6;27596:72;:::i;:::-;27304:371;;;;;;;:::o;27681:553::-;;27896:3;27885:9;27881:19;27873:27;;27910:71;27978:1;27967:9;27963:17;27954:6;27910:71;:::i;:::-;27991:72;28059:2;28048:9;28044:18;28035:6;27991:72;:::i;:::-;28073;28141:2;28130:9;28126:18;28117:6;28073:72;:::i;:::-;28155;28223:2;28212:9;28208:18;28199:6;28155:72;:::i;:::-;27863:371;;;;;;;:::o;28240:98::-;;28325:5;28319:12;28309:22;;28298:40;;;:::o;28344:99::-;;28430:5;28424:12;28414:22;;28403:40;;;:::o;28449:147::-;;28587:3;28572:18;;28562:34;;;;:::o;28602:169::-;;28720:6;28715:3;28708:19;28760:4;28755:3;28751:14;28736:29;;28698:73;;;;:::o;28777:305::-;;28836:20;28854:1;28836:20;:::i;:::-;28831:25;;28870:20;28888:1;28870:20;:::i;:::-;28865:25;;29024:1;28956:66;28952:74;28949:1;28946:81;28943:2;;;29030:18;;:::i;:::-;28943:2;29074:1;29071;29067:9;29060:16;;28821:261;;;;:::o;29088:185::-;;29145:20;29163:1;29145:20;:::i;:::-;29140:25;;29179:20;29197:1;29179:20;:::i;:::-;29174:25;;29218:1;29208:2;;29223:18;;:::i;:::-;29208:2;29265:1;29262;29258:9;29253:14;;29130:143;;;;:::o;29279:348::-;;29342:20;29360:1;29342:20;:::i;:::-;29337:25;;29376:20;29394:1;29376:20;:::i;:::-;29371:25;;29564:1;29496:66;29492:74;29489:1;29486:81;29481:1;29474:9;29467:17;29463:105;29460:2;;;29571:18;;:::i;:::-;29460:2;29619:1;29616;29612:9;29601:20;;29327:300;;;;:::o;29633:191::-;;29693:20;29711:1;29693:20;:::i;:::-;29688:25;;29727:20;29745:1;29727:20;:::i;:::-;29722:25;;29766:1;29763;29760:8;29757:2;;;29771:18;;:::i;:::-;29757:2;29816:1;29813;29809:9;29801:17;;29678:146;;;;:::o;29830:96::-;;29896:24;29914:5;29896:24;:::i;:::-;29885:35;;29875:51;;;:::o;29932:90::-;;30009:5;30002:13;29995:21;29984:32;;29974:48;;;:::o;30028:122::-;;30120:24;30138:5;30120:24;:::i;:::-;30109:35;;30099:51;;;:::o;30156:89::-;;30232:6;30225:5;30221:18;30210:29;;30200:45;;;:::o;30251:126::-;;30328:42;30321:5;30317:54;30306:65;;30296:81;;;:::o;30383:77::-;;30449:5;30438:16;;30428:32;;;:::o;30466:180::-;;30580:60;30634:5;30580:60;:::i;:::-;30567:73;;30557:89;;;:::o;30652:136::-;;30758:24;30776:5;30758:24;:::i;:::-;30745:37;;30735:53;;;:::o;30794:178::-;;30907:59;30960:5;30907:59;:::i;:::-;30894:72;;30884:88;;;:::o;30978:135::-;;31083:24;31101:5;31083:24;:::i;:::-;31070:37;;31060:53;;;:::o;31119:174::-;;31226:61;31281:5;31226:61;:::i;:::-;31213:74;;31203:90;;;:::o;31299:137::-;;31406:24;31424:5;31406:24;:::i;:::-;31393:37;;31383:53;;;:::o;31442:168::-;;31550:54;31598:5;31550:54;:::i;:::-;31537:67;;31527:83;;;:::o;31616:130::-;;31716:24;31734:5;31716:24;:::i;:::-;31703:37;;31693:53;;;:::o;31752:307::-;31820:1;31830:113;31844:6;31841:1;31838:13;31830:113;;;31929:1;31924:3;31920:11;31914:18;31910:1;31905:3;31901:11;31894:39;31866:2;31863:1;31859:10;31854:15;;31830:113;;;31961:6;31958:1;31955:13;31952:2;;;32041:1;32032:6;32027:3;32023:16;32016:27;31952:2;31801:258;;;;:::o;32065:233::-;;32127:24;32145:5;32127:24;:::i;:::-;32118:33;;32173:66;32166:5;32163:77;32160:2;;;32243:18;;:::i;:::-;32160:2;32290:1;32283:5;32279:13;32272:20;;32108:190;;;:::o;32304:180::-;32352:77;32349:1;32342:88;32449:4;32446:1;32439:15;32473:4;32470:1;32463:15;32490:180;32538:77;32535:1;32528:88;32635:4;32632:1;32625:15;32659:4;32656:1;32649:15;32676:102;;32768:2;32764:7;32759:2;32752:5;32748:14;32744:28;32734:38;;32724:54;;;:::o;32784:156::-;32924:8;32920:1;32912:6;32908:14;32901:32;32890:50;:::o;32946:225::-;33086:34;33082:1;33074:6;33070:14;33063:58;33155:8;33150:2;33142:6;33138:15;33131:33;33052:119;:::o;33177:155::-;33317:7;33313:1;33305:6;33301:14;33294:31;33283:49;:::o;33338:156::-;33478:8;33474:1;33466:6;33462:14;33455:32;33444:50;:::o;33500:160::-;33640:12;33636:1;33628:6;33624:14;33617:36;33606:54;:::o;33666:225::-;33806:34;33802:1;33794:6;33790:14;33783:58;33875:8;33870:2;33862:6;33858:15;33851:33;33772:119;:::o;33897:159::-;34037:11;34033:1;34025:6;34021:14;34014:35;34003:53;:::o;34062:158::-;34202:10;34198:1;34190:6;34186:14;34179:34;34168:52;:::o;34226:158::-;34366:10;34362:1;34354:6;34350:14;34343:34;34332:52;:::o;34390:161::-;34530:13;34526:1;34518:6;34514:14;34507:37;34496:55;:::o;34557:182::-;34697:34;34693:1;34685:6;34681:14;34674:58;34663:76;:::o;34745:160::-;34885:12;34881:1;34873:6;34869:14;34862:36;34851:54;:::o;34911:179::-;35051:31;35047:1;35039:6;35035:14;35028:55;35017:73;:::o;35096:156::-;35236:8;35232:1;35224:6;35220:14;35213:32;35202:50;:::o;35258:229::-;35398:34;35394:1;35386:6;35382:14;35375:58;35467:12;35462:2;35454:6;35450:15;35443:37;35364:123;:::o;35493:181::-;35633:33;35629:1;35621:6;35617:14;35610:57;35599:75;:::o;35680:122::-;35753:24;35771:5;35753:24;:::i;:::-;35746:5;35743:35;35733:2;;35792:1;35789;35782:12;35733:2;35723:79;:::o;35808:116::-;35878:21;35893:5;35878:21;:::i;:::-;35871:5;35868:32;35858:2;;35914:1;35911;35904:12;35858:2;35848:76;:::o;35930:174::-;36029:50;36073:5;36029:50;:::i;:::-;36022:5;36019:61;36009:2;;36094:1;36091;36084:12;36009:2;35999:105;:::o;36110:122::-;36183:24;36201:5;36183:24;:::i;:::-;36176:5;36173:35;36163:2;;36222:1;36219;36212:12;36163:2;36153:79;:::o

ipfs://4e64dfb1c99f7481151b19654de08aa81f5fff0b14779c4b5fce7f36e02d7f56