Contract 0x03edb31BeCc296d45670790c947150DAfEC2E238

/**
 *Submitted for verification at BscScan.com on 2020-11-23
*/

// File: traphouse-lib/contracts/math/SafeMath.sol

// SPDX-License-Identifier: MIT

pragma solidity >=0.4.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, 'SafeMath: addition overflow');

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

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

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

        return c;
    }

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

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

    function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = x < y ? x : y;
    }

    // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
    function sqrt(uint256 y) internal pure returns (uint256 z) {
        if (y > 3) {
            z = y;
            uint256 x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }
}

// File: traphouse-lib/contracts/token/BEP20/IBEP20.sol

pragma solidity >=0.4.0;

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

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

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

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

    /**
     * @dev Returns the bep token owner.
     */
    function getOwner() external view returns (address);

    /**
     * @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: traphouse-lib/contracts/utils/Address.sol

pragma solidity ^0.6.2;

/**
 * @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) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            codehash := extcodehash(account)
        }
        return (codehash != accountHash && codehash != 0x0);
    }

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

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{value: amount}('');
        require(success, 'Address: unable to send value, recipient may have reverted');
    }

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

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

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

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

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 weiValue,
        string memory errorMessage
    ) private returns (bytes memory) {
        require(isContract(target), 'Address: call to non-contract');

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{value: weiValue}(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: traphouse-lib/contracts/token/BEP20/SafeBEP20.sol

pragma solidity ^0.6.0;




/**
 * @title SafeBEP20
 * @dev Wrappers around BEP20 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 SafeBEP20 for IBEP20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeBEP20 {
    using SafeMath for uint256;
    using Address for address;

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

    function safeTransferFrom(
        IBEP20 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
     * {IBEP20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IBEP20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            'SafeBEP20: approve from non-zero to non-zero allowance'
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

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

    function safeDecreaseAllowance(
        IBEP20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(
            value,
            'SafeBEP20: decreased allowance below zero'
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IBEP20 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, 'SafeBEP20: low-level call failed');
        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
        }
    }
}

// File: traphouse-lib/contracts/GSN/Context.sol

pragma solidity >=0.4.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 GSN 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.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor() internal {}

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

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

// File: traphouse-lib/contracts/access/Ownable.sol

pragma solidity >=0.4.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.
 */
contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), 'Ownable: new owner is the zero address');
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: traphouse-lib/contracts/token/BEP20/BEP20.sol

pragma solidity >=0.4.0;






/**
 * @dev Implementation of the {IBEP20} 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 {BEP20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-BEP20-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 BEP20 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 {IBEP20-approve}.
 */
contract BEP20 is Context, IBEP20, Ownable {
    using SafeMath for uint256;
    using Address for address;

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

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

    /**
     * @dev Returns the bep token owner.
     */
    function getOwner() external override view returns (address) {
        return owner();
    }

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

    /**
     * @dev Returns the token decimals.
     */
    function decimals() public override view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev Returns the token symbol.
     */
    function symbol() public override view returns (string memory) {
        return _symbol;
    }

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

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

    /**
     * @dev See {BEP20-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 override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

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

    /**
     * @dev See {BEP20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {BEP20};
     *
     * 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 override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance')
        );
        return true;
    }

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

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {BEP20-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 returns (bool) {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero')
        );
        return true;
    }

    /**
     * @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing
     * the total supply.
     *
     * Requirements
     *
     * - `msg.sender` must be the token owner
     */
    function mint(uint256 amount) public onlyOwner returns (bool) {
        _mint(_msgSender(), amount);
        return true;
    }

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

        _balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

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

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

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

        _balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is 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 {
        require(owner != address(0), 'BEP20: approve from the zero address');
        require(spender != address(0), 'BEP20: approve to the zero address');

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

    /**
     * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(
            account,
            _msgSender(),
            _allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance')
        );
    }
}

// File: contracts/DrugsToken.sol

pragma solidity 0.6.12;


// Drugs
contract DrugsTokenV2 is BEP20('DrugsV2', 'DRUGS') {
    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (OriginalGangster).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
    }
    // burn logic
    function burn(uint256 amount) public {
        _burn(_msgSender(), amount);
    }
    // interactive burn logic
    function burnFrom(address account, uint256 amount) public {
        uint256 decreasedAllowance = allowance(account, _msgSender()).sub(
            amount,
            'BEP20: burn amount exceeds allowance'
        );

        _approve(account, _msgSender(), decreasedAllowance);
        _burn(account, amount);
    }
}

// File: contracts/TheClub.sol

pragma solidity 0.6.12;



// TheClub
contract TheClubV2 is BEP20('Super Hoes', 'HOES') {
    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (OriginalGangster).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
    }

    function burn(address _from ,uint256 _amount) public onlyOwner {
        _burn(_from, _amount);
    }

    // The DRUGS TOKEN!
    DrugsTokenV2 public drugs;

    constructor(
        DrugsTokenV2 _drugs
    ) public {
        drugs = _drugs;
    }

    // Safe drugs transfer function, just in case if rounding error causes pool to not have enough DRUGs.
    function safeDrugsTransfer(address _to, uint256 _amount) public onlyOwner {
        uint256 drugsBal = drugs.balanceOf(address(this));
        if (_amount > drugsBal) {
            drugs.transfer(_to, drugsBal);
        } else {
            drugs.transfer(_to, _amount);
        }
    }
}

// File: contracts/OriginalGangster.sol

pragma solidity 0.6.12;








// OriginalGangster is the master of Drugs. He can make Drugs and he is a fair guy.
contract OriginalGangsterV2 is Ownable {
    using SafeMath for uint256;
    using SafeBEP20 for IBEP20;

    // Info of each user.
    struct UserInfo {
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        //
        // We do some fancy math here. Basically, any point in time, the amount of DRUGs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accDrugsPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accDrugsPerShare` (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 {
        IBEP20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. DRUGs to distribute per block.
        uint256 lastRewardBlock;  // Last block number that DRUGs distribution occurs.
        uint256 accDrugsPerShare; // Accumulated DRUGs per share, times 1e12. See below.
    }

    // The DRUGS TOKEN!
    DrugsTokenV2 public drugs;
    // The HOES TOKEN!
    TheClubV2 public hoes;
    // Dev address.
    address public devaddr;
    // DRUGS tokens created per block.
    uint256 public drugsPerBlock;
    // Bonus muliplier for early drugs makers.
    uint256 public BONUS_MULTIPLIER = 1;

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping (uint256 => mapping (address => UserInfo)) public userInfo;
    // Total allocation poitns. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block number when DRUGS mining starts.
    uint256 public startBlock;
    // DEAD address to send old drugs
    address constant dead = 0x000000000000000000000000000000000000dEaD;
    // Old Drugs (DrugsV1)
    IBEP20 public olddrugs;

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

    constructor(
        DrugsTokenV2 _drugs,
        TheClubV2 _hoes,
        IBEP20 _olddrugs,
        address _devaddr,
        uint256 _drugsPerBlock,
        uint256 _startBlock
    ) public {
        drugs = _drugs;
        hoes = _hoes;
        olddrugs = _olddrugs;
        devaddr = _devaddr;
        drugsPerBlock = _drugsPerBlock;
        startBlock = _startBlock;

        // staking pool
        poolInfo.push(PoolInfo({
            lpToken: _drugs,
            allocPoint: 1000,
            lastRewardBlock: startBlock,
            accDrugsPerShare: 0
        }));

        totalAllocPoint = 1000;

    }

    function updateMultiplier(uint256 multiplierNumber) public onlyOwner {
        BONUS_MULTIPLIER = multiplierNumber;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    // 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 _allocPoint, IBEP20 _lpToken, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accDrugsPerShare: 0
        }));
        updateStakingPool();
    }

    // Update the given pool's DRUGS allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        uint256 prevAllocPoint = poolInfo[_pid].allocPoint;
        poolInfo[_pid].allocPoint = _allocPoint;
        if (prevAllocPoint != _allocPoint) {
            updateStakingPool();
        }
    }

    function updateStakingPool() internal {
        uint256 length = poolInfo.length;
        uint256 points = 0;
        for (uint256 pid = 1; pid < length; ++pid) {
            points = points.add(poolInfo[pid].allocPoint);
        }
        if (points != 0) {
            points = points.div(4);
            totalAllocPoint = totalAllocPoint.sub(poolInfo[0].allocPoint).add(points);
            poolInfo[0].allocPoint = points;
        }
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
        return _to.sub(_from).mul(BONUS_MULTIPLIER);
    }

    // View function to see pending DRUGs on frontend.
    function pendingDrugs(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accDrugsPerShare = pool.accDrugsPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
            uint256 drugsReward = multiplier.mul(drugsPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
            accDrugsPerShare = accDrugsPerShare.add(drugsReward.mul(1e12).div(lpSupply));
        }
        return user.amount.mul(accDrugsPerShare).div(1e12).sub(user.rewardDebt);
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }


    // 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.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 drugsReward = multiplier.mul(drugsPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
        drugs.mint(devaddr, drugsReward.div(10));
        drugs.mint(address(hoes), drugsReward);
        pool.accDrugsPerShare = pool.accDrugsPerShare.add(drugsReward.mul(1e12).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to OriginalGangster for DRUGS allocation.
    function deposit(uint256 _pid, uint256 _amount) public {

        require (_pid != 0, 'deposit DRUGS by staking');

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accDrugsPerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
                safeDrugsTransfer(msg.sender, pending);
            }
        }
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accDrugsPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from OriginalGangster.
    function withdraw(uint256 _pid, uint256 _amount) public {

        require (_pid != 0, 'withdraw DRUGS by unstaking');
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");

        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accDrugsPerShare).div(1e12).sub(user.rewardDebt);
        if(pending > 0) {
            safeDrugsTransfer(msg.sender, pending);
        }
        if(_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accDrugsPerShare).div(1e12);
        emit Withdraw(msg.sender, _pid, _amount);
    }

    // Exchange OLD Drugs for DrugsV2 (mints new supply)
    function upgradeDrugs(uint256 _amount) public {
        require (_amount != 0, 'Forgot to enter an amount bitch');
        olddrugs.transferFrom(address(msg.sender), address(dead), _amount);
        drugs.mint(msg.sender, _amount);
    }

    // Stake DRUGS tokens to OriginalGangster
    function enterStaking(uint256 _amount) public {
        PoolInfo storage pool = poolInfo[0];
        UserInfo storage user = userInfo[0][msg.sender];
        updatePool(0);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accDrugsPerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
                safeDrugsTransfer(msg.sender, pending);
            }
        }
        if(_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accDrugsPerShare).div(1e12);

        hoes.mint(msg.sender, _amount);
        emit Deposit(msg.sender, 0, _amount);
    }

    // Withdraw DRUGS tokens from STAKING.
    function leaveStaking(uint256 _amount) public {
        PoolInfo storage pool = poolInfo[0];
        UserInfo storage user = userInfo[0][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(0);
        uint256 pending = user.amount.mul(pool.accDrugsPerShare).div(1e12).sub(user.rewardDebt);
        if(pending > 0) {
            safeDrugsTransfer(msg.sender, pending);
        }
        if(_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accDrugsPerShare).div(1e12);

        hoes.burn(msg.sender, _amount);
        emit Withdraw(msg.sender, 0, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        require (_pid != 0, 'Use leaveStaking you little bitch');
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        pool.lpToken.safeTransfer(address(msg.sender), user.amount);
        emit EmergencyWithdraw(msg.sender, _pid, user.amount);
        user.amount = 0;
        user.rewardDebt = 0;
    }

    // Safe drugs transfer function, just in case if rounding error causes pool to not have enough DRUGs.
    function safeDrugsTransfer(address _to, uint256 _amount) internal {
        hoes.safeDrugsTransfer(_to, _amount);
    }

    // Update dev address by the previous dev.
    function dev(address _devaddr) public {
        require(msg.sender == devaddr, "dev: wut?");
        devaddr = _devaddr;
    }
}

[{"inputs":[{"internalType":"contract DrugsTokenV2","name":"_drugs","type":"address"},{"internalType":"contract TheClubV2","name":"_hoes","type":"address"},{"internalType":"contract IBEP20","name":"_olddrugs","type":"address"},{"internalType":"address","name":"_devaddr","type":"address"},{"internalType":"uint256","name":"_drugsPerBlock","type":"uint256"},{"internalType":"uint256","name":"_startBlock","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"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":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"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":"BONUS_MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IBEP20","name":"_lpToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devaddr","type":"address"}],"name":"dev","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devaddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"drugs","outputs":[{"internalType":"contract DrugsTokenV2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"drugsPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"enterStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hoes","outputs":[{"internalType":"contract TheClubV2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"leaveStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"olddrugs","outputs":[{"internalType":"contract IBEP20","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":"pendingDrugs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IBEP20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accDrugsPerShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"bool","name":"_withUpdate","type":"bool"}],"name":"set","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":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"multiplierNumber","type":"uint256"}],"name":"updateMultiplier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"upgradeDrugs","outputs":[],"stateMutability":"nonpayable","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":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000339550404ca4d831d12b1b2e4768869997390010000000000000000000000000fe60b258204398f008581775f08d2b43fb7b422b000000000000000000000000fd26889cd6454d8751562f1c0fcf88b18b46f7b7000000000000000000000000ed4fb67616353f5384b522b07bf3f584f83487f90000000000000000000000000000000000000000000000000ff59ee833b30000000000000000000000000000000000000000000000000000000000000025cd18

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 000000000000000000000000339550404ca4d831d12b1b2e4768869997390010
Arg [1] : 000000000000000000000000fe60b258204398f008581775f08d2b43fb7b422b
Arg [2] : 000000000000000000000000fd26889cd6454d8751562f1c0fcf88b18b46f7b7
Arg [3] : 000000000000000000000000ed4fb67616353f5384b522b07bf3f584f83487f9
Arg [4] : 0000000000000000000000000000000000000000000000000ff59ee833b30000
Arg [5] : 000000000000000000000000000000000000000000000000000000000025cd18

35499:11926:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38788:95;;;:::i;:::-;;;;;;;;;;;;;;;;45743:764;;;;;;;;;;;;;;;;-1:-1:-1;45743:764:0;;:::i;:::-;;37222:26;;;;;;;;;;;;;;;;-1:-1:-1;37222:26:0;;:::i;:::-;;;;-1:-1:-1;;;;;37222:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37465:34;;;:::i;39052:544::-;;;;;;;;;;;;;;;;-1:-1:-1;39052:544:0;;;-1:-1:-1;;;;;39052:544:0;;;;;;;;;;;;:::i;44618:241::-;;;;;;;;;;;;;;;;-1:-1:-1;44618:241:0;;:::i;44914:777::-;;;;;;;;;;;;;;;;-1:-1:-1;44914:777:0;;:::i;43744:808::-;;;;;;;;;;;;;;;;-1:-1:-1;43744:808:0;;;;;;;:::i;37557:25::-;;;:::i;42002:790::-;;;;;;;;;;;;;;;;-1:-1:-1;42002:790:0;;:::i;36950:21::-;;;:::i;:::-;;;;-1:-1:-1;;;;;36950:21:0;;;;;;;;;;;;;;46578:423;;;;;;;;;;;;;;;;-1:-1:-1;46578:423:0;;:::i;38657:123::-;;;;;;;;;;;;;;;;-1:-1:-1;38657:123:0;;:::i;41744:180::-;;;:::i;39693:456::-;;;;;;;;;;;;;;;;-1:-1:-1;39693:456:0;;;;;;;;;;;;;;:::i;37729:22::-;;;:::i;22557:140::-;;;:::i;37151:35::-;;;:::i;47293:129::-;;;;;;;;;;;;;;;;-1:-1:-1;47293:129:0;-1:-1:-1;;;;;47293:129:0;;:::i;21915:79::-;;;:::i;40686:143::-;;;;;;;;;;;;;;;;-1:-1:-1;40686:143:0;;;;;;;:::i;37304:66::-;;;;;;;;;;;;;;;;-1:-1:-1;37304:66:0;;;;;;-1:-1:-1;;;;;37304:66:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;40893:768;;;;;;;;;;;;;;;;-1:-1:-1;40893:768:0;;;;;;-1:-1:-1;;;;;40893:768:0;;:::i;36894:25::-;;;:::i;36999:22::-;;;:::i;42868:818::-;;;;;;;;;;;;;;;;-1:-1:-1;42868:818:0;;;;;;;:::i;22852:109::-;;;;;;;;;;;;;;;;-1:-1:-1;22852:109:0;-1:-1:-1;;;;;22852:109:0;;:::i;37068:28::-;;;:::i;38788:95::-;38860:8;:15;38788:95;:::o;45743:764::-;45800:21;45824:8;45833:1;45824:11;;;;;;;;;;;;;;;;45882:10;45870:23;;:11;:23;;;:11;:23;;;45912:11;;45824;;;;;;;;-1:-1:-1;45912:22:0;-1:-1:-1;45912:22:0;45904:53;;;;;-1:-1:-1;;;45904:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;45968:13;45979:1;45968:10;:13::i;:::-;45992:15;46010:69;46063:4;:15;;;46010:48;46053:4;46010:38;46026:4;:21;;;46010:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48::i;:::-;:52;;:69::i;:::-;45992:87;-1:-1:-1;46093:11:0;;46090:81;;46121:38;46139:10;46151:7;46121:17;:38::i;:::-;46184:11;;46181:151;;46226:11;;:24;;46242:7;46226:15;:24::i;:::-;46212:38;;46265:12;;:55;;-1:-1:-1;;;;;46265:12:0;46299:10;46312:7;46265:25;:55::i;:::-;46376:21;;;;46360:11;;:48;;46403:4;;46360:38;;:15;:38::i;:48::-;46342:15;;;:66;46421:4;;:30;;;;;;46431:10;46421:30;;;;;;;;;;;;-1:-1:-1;;;;;46421:4:0;;;;:9;;:30;;;;;:4;;:30;;;;;;;;:4;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;46467:32:0;;;;;;;;46488:1;;-1:-1:-1;46476:10:0;;-1:-1:-1;46467:32:0;;;;;;;;;45743:764;;;;:::o;37222:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;37222:26:0;;;;-1:-1:-1;37222:26:0;;;:::o;37465:34::-;;;;:::o;39052:544::-;22137:12;:10;:12::i;:::-;22127:6;;-1:-1:-1;;;;;22127:6:0;;;:22;;;22119:67;;;;;-1:-1:-1;;;22119:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39153:11:::1;39149:61;;;39181:17;:15;:17::i;:::-;39220:23;39261:10;;39246:12;:25;:53;;39289:10;;39246:53;;;39274:12;39246:53;39328:15;::::0;39220:79;;-1:-1:-1;39328:32:0::1;::::0;39348:11;39328:19:::1;:32::i;:::-;39310:15;:50:::0;39385:172:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;39385:172:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;39385:172:0;;;;;;39371:8:::1;:187:::0;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;39371:187:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;39569:19:::1;:17;:19::i;:::-;22197:1;39052:544:::0;;;:::o;44618:241::-;44684:12;44675:57;;;;;-1:-1:-1;;;44675:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;44743:8;;:66;;;-1:-1:-1;;;44743:66:0;;44773:10;44743:66;;;;37652:42;44743:66;;;;;;;;;;;;-1:-1:-1;;;;;44743:8:0;;;;:21;;:66;;;;;;;;;;;;;;;:8;;:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;44820:5:0;;:31;;;-1:-1:-1;;;44820:31:0;;44831:10;44820:31;;;;;;;;;;;;-1:-1:-1;;;;;44820:5:0;;;;:10;;:31;;;;;:5;;:31;;;;;;;;:5;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44618:241;:::o;44914:777::-;44971:21;44995:8;45004:1;44995:11;;;;;;;;;;;;;;;;45053:10;45041:23;;:11;:23;;;:11;:23;;44995:11;;;;;;-1:-1:-1;45041:23:0;45075:13;;:10;:13::i;:::-;45103:11;;:15;45099:238;;45135:15;45153:69;45206:4;:15;;;45153:48;45196:4;45153:38;45169:4;:21;;;45153:4;:11;;;:15;;:38;;;;:::i;:69::-;45135:87;-1:-1:-1;45240:11:0;;45237:89;;45272:38;45290:10;45302:7;45272:17;:38::i;:::-;45099:238;;45350:11;;45347:170;;45378:12;;:74;;-1:-1:-1;;;;;45378:12:0;45416:10;45437:4;45444:7;45378:29;:74::i;:::-;45481:11;;:24;;45497:7;45481:15;:24::i;:::-;45467:38;;45347:170;45561:21;;;;45545:11;;:48;;45588:4;;45545:38;;:15;:38::i;:48::-;45527:15;;;:66;45606:4;;:30;;;-1:-1:-1;;;45606:30:0;;45616:10;45606:30;;;;;;;;;;;;-1:-1:-1;;;;;45606:4:0;;;;:9;;:30;;;;;:4;;:30;;;;;;;;:4;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;45652:31:0;;;;;;;;45672:1;;-1:-1:-1;45660:10:0;;-1:-1:-1;45652:31:0;;;;;;;;;44914:777;;;:::o;43744:808::-;43822:9;43813:50;;;;;-1:-1:-1;;;43813:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;43874:21;43898:8;43907:4;43898:14;;;;;;;;;;;;;;;;43947;;;:8;:14;;;;;;43962:10;43947:26;;;;;;;43992:11;;43898:14;;;;;;;;-1:-1:-1;43992:22:0;-1:-1:-1;43992:22:0;43984:53;;;;;-1:-1:-1;;;43984:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;44050:16;44061:4;44050:10;:16::i;:::-;44077:15;44095:69;44148:4;:15;;;44095:48;44138:4;44095:38;44111:4;:21;;;44095:4;:11;;;:15;;:38;;;;:::i;:69::-;44077:87;-1:-1:-1;44178:11:0;;44175:81;;44206:38;44224:10;44236:7;44206:17;:38::i;:::-;44269:11;;44266:151;;44311:11;;:24;;44327:7;44311:15;:24::i;:::-;44297:38;;44350:12;;:55;;-1:-1:-1;;;;;44350:12:0;44384:10;44397:7;44350:25;:55::i;:::-;44461:21;;;;44445:11;;:48;;44488:4;;44445:38;;:15;:38::i;:48::-;44427:15;;;:66;44509:35;;;;;;;;44530:4;;44518:10;;44509:35;;;;;;;;;43744:808;;;;;:::o;37557:25::-;;;;:::o;42002:790::-;42054:21;42078:8;42087:4;42078:14;;;;;;;;;;;;;;;;;;42054:38;;42123:4;:20;;;42107:12;:36;42103:75;;42160:7;;;42103:75;42207:12;;:37;;;-1:-1:-1;;;42207:37:0;;42238:4;42207:37;;;;;;42188:16;;-1:-1:-1;;;;;42207:12:0;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42207:37:0;;-1:-1:-1;42259:13:0;42255:102;;-1:-1:-1;42312:12:0;42289:20;;;;:35;42339:7;;42255:102;42367:18;42388:49;42402:4;:20;;;42424:12;42388:13;:49::i;:::-;42367:70;;42448:19;42470:71;42525:15;;42470:50;42504:4;:15;;;42470:29;42485:13;;42470:10;:14;;:29;;;;:::i;:::-;:33;;:50::i;:71::-;42552:5;;42563:7;;42448:93;;-1:-1:-1;;;;;;42552:5:0;;;;:10;;42563:7;42572:19;42448:93;42588:2;42572:15;:19::i;:::-;42552:40;;;;;;;;;;;;;-1:-1:-1;;;;;42552:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;42603:5:0;;42622:4;;42603:38;;;-1:-1:-1;;;42603:38:0;;-1:-1:-1;;;;;42622:4:0;;;42603:38;;;;;;;;;;;;:5;;;;;-1:-1:-1;42603:10:0;;-1:-1:-1;42603:38:0;;;;;:5;;:38;;;;;;;:5;;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42676:62;42702:35;42728:8;42702:21;42718:4;42702:11;:15;;:21;;;;:::i;:35::-;42676:21;;;;;:25;:62::i;:::-;42652:21;;;:86;-1:-1:-1;;42772:12:0;42749:20;;;;:35;;;;-1:-1:-1;42002:790:0;;:::o;36950:21::-;;;-1:-1:-1;;;;;36950:21:0;;:::o;46578:423::-;46646:9;46637:56;;;;-1:-1:-1;;;46637:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46704:21;46728:8;46737:4;46728:14;;;;;;;;;;;;;;;;46777;;;:8;:14;;;;;;46792:10;46777:26;;;;;;;;46861:11;;46728:14;;;;;;;46814:12;;46728:14;;-1:-1:-1;46814:59:0;;-1:-1:-1;;;;;46814:12:0;;;;;46792:10;46814:25;:59::i;:::-;46925:11;;46889:48;;;;;;;46919:4;;46907:10;;46889:48;;;;;;;;;46962:1;46948:15;;;46974;;;;:19;-1:-1:-1;;46578:423:0:o;38657:123::-;22137:12;:10;:12::i;:::-;22127:6;;-1:-1:-1;;;;;22127:6:0;;;:22;;;22119:67;;;;;-1:-1:-1;;;22119:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38737:16:::1;:35:::0;38657:123::o;41744:180::-;41806:8;:15;41789:14;41832:85;41860:6;41854:3;:12;41832:85;;;41890:15;41901:3;41890:10;:15::i;:::-;41868:5;;41832:85;;;;41744:180;:::o;39693:456::-;22137:12;:10;:12::i;:::-;22127:6;;-1:-1:-1;;;;;22127:6:0;;;:22;;;22119:67;;;;;-1:-1:-1;;;22119:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39791:11:::1;39787:61;;;39819:17;:15;:17::i;:::-;39876:63;39927:11;39876:46;39896:8;39905:4;39896:14;;;;;;;;;;;;;;;;;;:25;;;39876:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:63::i;:::-;39858:15;:81;;;;39950:22;39975:8;39984:4;39975:14;;;;;;;;;;;;;;;;;;:25;;;39950:50;;40039:11;40011:8;40020:4;40011:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;40083:11;40065:14;:29;40061:81;;40111:19;:17;:19::i;37729:22::-:0;;;-1:-1:-1;;;;;37729:22:0;;:::o;22557:140::-;22137:12;:10;:12::i;:::-;22127:6;;-1:-1:-1;;;;;22127:6:0;;;:22;;;22119:67;;;;;-1:-1:-1;;;22119:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22656:1:::1;22640:6:::0;;22619:40:::1;::::0;-1:-1:-1;;;;;22640:6:0;;::::1;::::0;22619:40:::1;::::0;22656:1;;22619:40:::1;22687:1;22670:19:::0;;-1:-1:-1;;22670:19:0::1;::::0;;22557:140::o;37151:35::-;;;;:::o;47293:129::-;47364:7;;-1:-1:-1;;;;;47364:7:0;47350:10;:21;47342:43;;;;;-1:-1:-1;;;47342:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;47396:7;:18;;-1:-1:-1;;47396:18:0;-1:-1:-1;;;;;47396:18:0;;;;;;;;;;47293:129::o;21915:79::-;21953:7;21980:6;-1:-1:-1;;;;;21980:6:0;21915:79;:::o;40686:143::-;40804:16;;40758:7;;40785:36;;:14;:3;40793:5;40785:7;:14::i;:36::-;40778:43;;40686:143;;;;;:::o;37304:66::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;40893:768::-;40967:7;40987:21;41011:8;41020:4;41011:14;;;;;;;;;;;;;;;;41060;;;:8;:14;;;;;;-1:-1:-1;;;;;41060:21:0;;;;;;;;;;;41011:14;;;;;;;41119:21;;;;41170:12;;:37;;-1:-1:-1;;;41170:37:0;;41201:4;41170:37;;;;;;;;;41011:14;;-1:-1:-1;41060:21:0;;41119;;41011:14;;41170:12;;;;;:22;;:37;;;;;41011:14;;41170:37;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41170:37:0;41237:20;;;;41170:37;;-1:-1:-1;41222:12:0;:35;:52;;;;-1:-1:-1;41261:13:0;;;41222:52;41218:354;;;41291:18;41312:49;41326:4;:20;;;41348:12;41312:13;:49::i;:::-;41291:70;;41376:19;41398:71;41453:15;;41398:50;41432:4;:15;;;41398:29;41413:13;;41398:10;:14;;:29;;;;:::i;:71::-;41376:93;-1:-1:-1;41503:57:0;41524:35;41550:8;41524:21;41376:93;41540:4;41524:15;:21::i;:35::-;41503:16;;:20;:57::i;:::-;41484:76;;41218:354;;;41589:64;41637:4;:15;;;41589:43;41627:4;41589:33;41605:16;41589:4;:11;;;:15;;:33;;;;:::i;:64::-;41582:71;40893:768;-1:-1:-1;;;;;;;40893:768:0:o;36894:25::-;;;-1:-1:-1;;;;;36894:25:0;;:::o;36999:22::-;;;-1:-1:-1;;;;;36999:22:0;;:::o;42868:818::-;42945:9;42936:47;;;;;-1:-1:-1;;;42936:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;42996:21;43020:8;43029:4;43020:14;;;;;;;;;;;;;;;;43069;;;:8;:14;;;;;;43084:10;43069:26;;;;;;;43020:14;;;;;;;;-1:-1:-1;43106:16:0;43078:4;43106:10;:16::i;:::-;43137:11;;:15;43133:238;;43169:15;43187:69;43240:4;:15;;;43187:48;43230:4;43187:38;43203:4;:21;;;43187:4;:11;;;:15;;:38;;;;:::i;:69::-;43169:87;-1:-1:-1;43274:11:0;;43271:89;;43306:38;43324:10;43336:7;43306:17;:38::i;:::-;43133:238;;43385:11;;43381:171;;43413:12;;:74;;-1:-1:-1;;;;;43413:12:0;43451:10;43472:4;43479:7;43413:29;:74::i;:::-;43516:11;;:24;;43532:7;43516:15;:24::i;:::-;43502:38;;43381:171;43596:21;;;;43580:11;;:48;;43623:4;;43580:38;;:15;:38::i;:48::-;43562:15;;;:66;43644:34;;;;;;;;43664:4;;43652:10;;43644:34;;;;;;;;;42868:818;;;;:::o;22852:109::-;22137:12;:10;:12::i;:::-;22127:6;;-1:-1:-1;;;;;22127:6:0;;;:22;;;22119:67;;;;;-1:-1:-1;;;22119:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22925:28:::1;22944:8;22925:18;:28::i;37068:::-:0;;;;:::o;2345:471::-;2403:7;2648:6;2644:47;;-1:-1:-1;2678:1:0;2671:8;;2644:47;2715:5;;;2719:1;2715;:5;:1;2739:5;;;;;:10;2731:56;;;;-1:-1:-1;;;2731:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3292:132;3350:7;3377:39;3381:1;3384;3377:39;;;;;;;;;;;;;;;;;:3;:39::i;1421:136::-;1479:7;1506:43;1510:1;1513;1506:43;;;;;;;;;;;;;;;;;:3;:43::i;47116:121::-;47193:4;;:36;;;;;;-1:-1:-1;;;;;47193:36:0;;;;;;;;;;;;;;;:4;;;;;:22;;:36;;;;;:4;;:36;;;;;;;:4;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47116:121;;:::o;16366:211::-;16510:58;;;-1:-1:-1;;;;;16510:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16533:23;16510:58;;;16483:86;;16503:5;;16483:19;:86::i;:::-;16366:211;;;:::o;20485:98::-;20565:10;20485:98;:::o;957:181::-;1015:7;1047:5;;;1071:6;;;;1063:46;;;;;-1:-1:-1;;;1063:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;40157:453;40223:8;:15;40206:14;40297:1;40278:115;40306:6;40300:3;:12;40278:115;;;40345:36;40356:8;40365:3;40356:13;;;;;;;;;;;;;;;;;;:24;;;40345:6;:10;;:36;;;;:::i;:::-;40336:45;-1:-1:-1;40314:5:0;;40278:115;;;-1:-1:-1;40407:11:0;;40403:200;;40444:13;:6;40455:1;40444:10;:13::i;:::-;40435:22;;40490:55;40538:6;40490:43;40510:8;40519:1;40510:11;;;;;;;40490:55;40472:15;:73;;;;40585:6;40560:8;40569:1;40560:11;;;;;;;;;;;;;;;;;;:22;;:31;;;;40157:453;;:::o;16585:248::-;16756:68;;;-1:-1:-1;;;;;16756:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;16756:68:0;;;16729:96;;16749:5;;16729:19;:96::i;23067:229::-;-1:-1:-1;;;;;23141:22:0;;23133:73;;;;-1:-1:-1;;;23133:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23243:6;;;23222:38;;-1:-1:-1;;;;;23222:38:0;;;;23243:6;;;23222:38;;;23271:6;:17;;-1:-1:-1;;23271:17:0;-1:-1:-1;;;;;23271:17:0;;;;;;;;;;23067:229::o;3920:312::-;4040:7;4075:12;4068:5;4060:28;;;;-1:-1:-1;;;4060:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4099:9;4115:1;4111;:5;;;;;;;3920:312;-1:-1:-1;;;;;3920:312:0:o;1860:226::-;1980:7;2016:12;2008:6;;;;2000:29;;;;-1:-1:-1;;;2000:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2052:5:0;;;1860:226::o;18901:774::-;19325:23;19351:69;19379:4;19351:69;;;;;;;;;;;;;;;;;19359:5;-1:-1:-1;;;;;19351:27:0;;;:69;;;;;:::i;:::-;19435:17;;19325:95;;-1:-1:-1;19435:21:0;19431:237;;19590:10;19579:30;;;;;;;;;;;;;;;-1:-1:-1;19579:30:0;19571:85;;;;-1:-1:-1;;;19571:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13197:230;13334:12;13366:53;13389:6;13397:4;13403:1;13406:12;13366:22;:53::i;:::-;13359:60;13197:230;-1:-1:-1;;;;13197:230:0:o;14685:1020::-;14858:12;14891:18;14902:6;14891:10;:18::i;:::-;14883:60;;;;;-1:-1:-1;;;14883:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;15017:12;15031:23;15058:6;-1:-1:-1;;;;;15058:11:0;15077:8;15087:4;15058:34;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;15058:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15016:76;;;;15107:7;15103:595;;;15138:10;-1:-1:-1;15131:17:0;;-1:-1:-1;15131:17:0;15103:595;15252:17;;:21;15248:439;;15515:10;15509:17;15576:15;15563:10;15559:2;15555:19;15548:44;15463:148;15651:20;;-1:-1:-1;;;15651:20:0;;;;;;;;;;;;;;;;;15658:12;;15651:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10060:641;10120:4;10601:20;;10431:66;10650:23;;;;;;:42;;-1:-1:-1;;10677:15:0;;;10642:51;-1:-1:-1;;10060:641:0:o

ipfs://a217c60b42c1eaeba0c4aff6f55ea95edac32cedf0b58f0ef35f65f564f43542