Contract 0xCb80F529724B9620145230A0C866AC2FACBE4e3D 5

/**
 *Submitted for verification at FtmScan.com on 2021-05-26
*/

// SPDX-License-Identifier: GPL-3.0-or-later Or MIT
pragma solidity >=0.8.0 <0.9.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;
    }
}



/*
 * @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.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) { // payable
        return msg.sender;
    }

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



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



interface IPancakePair {

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



interface IArtGallery {
	function lock (address _painter, uint256 amount) external;
}









interface IPancakeRouter01 {
    function factory() external view returns (address);
    function WETH() external view returns (address);

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

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

interface IPancakeRouter02 is IPancakeRouter01 {
    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;
}









/**
 * @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;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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


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





/**
 * @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 () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

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

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
















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

    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 name of the token.
     */
    function name() public override view returns (string memory) {
        return _name;
    }

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

    /**
    * @dev Returns the number of decimals used to get its user representation.
    */
    function decimals() public override view returns (uint8) {
        return _decimals;
    }

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

// BrushToken with Governance.
contract BrushToken is BEP20('PaintSwap Token', 'BRUSH') {
    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (Decorator).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
        _moveDelegates(address(0), _delegates[_to], _amount);
    }

    /// @notice Destroys  `_amount` token from `_from`. Must only be called by the owner (Decorator).
    function burn(address _from ,uint256 _amount) public onlyOwner {
        _burn(_from, _amount);
        _moveDelegates(_delegates[_from], address(0), _amount);
    }

    function burn(uint256 _amount) external {
        _burn(msg.sender, _amount);
        _moveDelegates(_delegates[msg.sender], address(0), _amount);
    }

    // Copied and modified from YAM code:
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
    // Which is copied and modified from COMPOUND:
    // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol

    /// @notice A record of each accounts delegate
    mapping (address => address) internal _delegates;

    /// @notice A checkpoint for marking number of votes from a given block
    struct Checkpoint {
        uint32 fromBlock;
        uint256 votes;
    }

    /// @notice A record of votes checkpoints for each account, by index
    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;

    /// @notice The number of checkpoints for each account
    mapping (address => uint32) public numCheckpoints;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    /// @notice The EIP-712 typehash for the delegation struct used by the contract
    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

    /// @notice A record of states for signing / validating signatures
    mapping (address => uint) public nonces;

      /// @notice An event thats emitted when an account changes its delegate
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /// @notice An event thats emitted when a delegate account's vote balance changes
    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

    /**
     * @notice Delegate votes from `msg.sender` to `delegatee`
     * @param delegator The address to get delegatee for
     */
    function delegates(address delegator)
        external
        view
        returns (address)
    {
        return _delegates[delegator];
    }

   /**
    * @notice Delegate votes from `msg.sender` to `delegatee`
    * @param delegatee The address to delegate votes to
    */
    function delegate(address delegatee) external {
        return _delegate(msg.sender, delegatee);
    }

    /**
     * @notice Delegates votes from signatory to `delegatee`
     * @param delegatee The address to delegate votes to
     * @param nonce The contract state required to match the signature
     * @param expiry The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function delegateBySig(
        address delegatee,
        uint nonce,
        uint expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
        external
    {
        bytes32 domainSeparator = keccak256(
            abi.encode(
                DOMAIN_TYPEHASH,
                keccak256(bytes(name())),
                block.chainid,
                address(this)
            )
        );

        bytes32 structHash = keccak256(
            abi.encode(
                DELEGATION_TYPEHASH,
                delegatee,
                nonce,
                expiry
            )
        );

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                domainSeparator,
                structHash
            )
        );

        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "BRUSH::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "BRUSH::delegateBySig: invalid nonce");
        require(block.timestamp <= expiry, "BRUSH::delegateBySig: signature expired");
        return _delegate(signatory, delegatee);
    }

    /**
     * @notice Gets the current votes balance for `account`
     * @param account The address to get votes balance
     * @return The number of current votes for `account`
     */
    function getCurrentVotes(address account)
        external
        view
        returns (uint256)
    {
        uint32 nCheckpoints = numCheckpoints[account];
        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
    }

    /**
     * @notice Determine the prior number of votes for an account as of a block number
     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
     * @param account The address of the account to check
     * @param blockNumber The block number to get the vote balance at
     * @return The number of votes the account had as of the given block
     */
    function getPriorVotes(address account, uint blockNumber)
        external
        view
        returns (uint256)
    {
        require(blockNumber < block.number, "BRUSH::getPriorVotes: not yet determined");

        uint32 nCheckpoints = numCheckpoints[account];
        if (nCheckpoints == 0) {
            return 0;
        }

        // First check most recent balance
        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
            return checkpoints[account][nCheckpoints - 1].votes;
        }

        // Next check implicit zero balance
        if (checkpoints[account][0].fromBlock > blockNumber) {
            return 0;
        }

        uint32 lower = 0;
        uint32 upper = nCheckpoints - 1;
        while (upper > lower) {
            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
            Checkpoint memory cp = checkpoints[account][center];
            if (cp.fromBlock == blockNumber) {
                return cp.votes;
            } else if (cp.fromBlock < blockNumber) {
                lower = center;
            } else {
                upper = center - 1;
            }
        }
        return checkpoints[account][lower].votes;
    }

    function _delegate(address delegator, address delegatee)
        internal
    {
        address currentDelegate = _delegates[delegator];
        uint256 delegatorBalance = balanceOf(delegator); // balance of underlying BRUSHs (not scaled);
        _delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
    }

    function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
        if (srcRep != dstRep && amount > 0) {
            if (srcRep != address(0)) {
                // decrease old representative
                uint32 srcRepNum = numCheckpoints[srcRep];
                uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
                uint256 srcRepNew = srcRepOld - (amount);
                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
            }

            if (dstRep != address(0)) {
                // increase new representative
                uint32 dstRepNum = numCheckpoints[dstRep];
                uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
                uint256 dstRepNew = dstRepOld + (amount);
                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
            }
        }
    }

    function _writeCheckpoint(
        address delegatee,
        uint32 nCheckpoints,
        uint256 oldVotes,
        uint256 newVotes
    )
        internal
    {
        uint32 blockNumber = safe32(block.number, "BRUSH::_writeCheckpoint: block number exceeds 32 bits");

        if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
            checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
        } else {
            checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
            numCheckpoints[delegatee] = nCheckpoints + 1;
        }

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
        require(n < 2**32, errorMessage);
        return uint32(n);
    }
}


// Decorator is the master of Painting. He can use brushes all day 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 BRUSH is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract Decorator 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 BRUSHs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accBrushPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accBrushPerShare` (and `lastRewardTime`) 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. BRUSHes to distribute per second.
        uint256 lastRewardTime;  // Last timestamp that BRUSH distribution occured.
        uint256 accBrushPerShare;   // Accumulated BRUSHs per share, times 1e12. See below.
    }

    // The $BRUSH token
    BrushToken public brush;

    // The $WFTM token address
    address public wftm;

    // BRUSH tokens created per second.
    uint256 public brushPerSecond;

    // An art gallery where the fruits of your labour are put (50% of the rewards) ready for admiration. Can be collected in 3 months time.
    IArtGallery public artGallery;

    // The router
    IPancakeRouter02 public router;

    // Info of each pool.
    PoolInfo[] public poolInfo;

    // Example 200 is 0.5%, type(uint).max is 0%
    uint inverseWithdrawFeeSingle;
    uint inverseWithdrawFeeLP;

    bool depositsDisabled;

    // 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 timestamp when BRUSH mining starts.
    uint256 public startTime;
    // How much of each LP token is eligible for burning
    mapping (IBEP20 => uint) public maxBurnAndBuyBackAmounts;

    struct Set {
        address[] values;
        mapping (address => bool) is_in;
    }

    Set private lps;

    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(
        BrushToken _brush,
        IArtGallery _artGallery,
        IPancakeRouter02 _router,
        address _wftm,
        uint256 _brushPerSecond,
        uint256 _startTime
    ) {
        brush = _brush;
        artGallery = _artGallery;
        router = _router;
        brushPerSecond = _brushPerSecond;
        startTime = _startTime;
        wftm = _wftm;
        inverseWithdrawFeeSingle = 200;
        inverseWithdrawFeeLP = 100;
        depositsDisabled = false;

        // brush staking pool
        poolInfo.push(
            PoolInfo({
                lpToken: _brush,
                allocPoint: 200,
                lastRewardTime: startTime,
                accBrushPerShare: 0
            })
        );
        universalApprove(_brush, address(router), type(uint).max);
        totalAllocPoint = 200;
        lps.values.push(address(_brush));
        lps.is_in[address(_brush)] = true;
    }

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

    function poolExists (address _lpToken) public view returns (bool) {
        return lps.is_in[_lpToken];
    }

    // Add a new lp to the pool. Can only be called by the owner. Will fail if it already exists.
    function add(uint256 _allocPoint, IBEP20 _lpToken, bool _withUpdate) public onlyOwner {
        require (!poolExists(address(_lpToken)), "This token already exists");
        address token0 = IPancakePair(address(_lpToken)).token0();
        address token1 = IPancakePair(address(_lpToken)).token1();
        require (token0 == address(brush) || token1 == address(brush) || token0 == wftm || token1 == wftm);
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardTime = block.timestamp > startTime ? block.timestamp : startTime;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardTime: lastRewardTime,
            accBrushPerShare: 0
        }));

        lps.values.push(address(_lpToken));
        lps.is_in[address(_lpToken)] = true;
        universalApprove (_lpToken, address(router), type(uint).max);
        universalApprove (IBEP20(token0), address(router), type(uint).max);
        universalApprove (IBEP20(token1), address(router), type(uint).max);
    }

    // Update the given pool's BRUSH allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
        require (poolExists (address(poolInfo[_pid].lpToken)), "pid does not yet exist");
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    // Return reward multiplier over the given _from to _to time.
    function getMultiplier(uint256 _from, uint256 _to) internal view returns (uint256) {
        if (_to < startTime) {
            return 0;
        }
        return _to - _from;
    }

    // View function to see pending BRUSHs on frontend. Locked up rewards are excluded, so this is really / 2 the amount
    // they are entitled too.
    function pendingBrush(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accBrushPerShare = pool.accBrushPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.timestamp > pool.lastRewardTime && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
            uint256 brushReward = multiplier.mul(brushPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
            accBrushPerShare = accBrushPerShare.add(brushReward.mul(1e12).div(lpSupply));
        }
        return (user.amount.mul(accBrushPerShare).div(1e12).sub(user.rewardDebt)) / 2;
    }

    // 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.timestamp <= pool.lastRewardTime) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0 || pool.allocPoint == 0) {
            pool.lastRewardTime = block.timestamp;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
        uint256 brushReward = multiplier.mul(brushPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
        brush.mint(address(this), brushReward);
        pool.accBrushPerShare = pool.accBrushPerShare.add(brushReward.mul(1e12).div(lpSupply));
        pool.lastRewardTime = block.timestamp;
    }

    function distributePendingRewards(uint256 _pending) private {
        if (_pending > 0) {
            // Half of this is staked.
            uint256 halfPending = _pending / 2;
            if (_pending > 1) {
                artGallery.lock(msg.sender, halfPending);
                safeBrushTransfer(address(artGallery), halfPending);
            }

            safeBrushTransfer(msg.sender, _pending - halfPending);
        }
    }

    function universalApprove(IBEP20 token, address to, uint256 amount) internal {
        if (amount == 0) {
            token.safeApprove(to, 0);
            return;
        }

        uint256 allowance = token.allowance(address(this), to);
        if (allowance < amount) {
            if (allowance > 0) {
                token.safeApprove(to, 0);
            }
            token.safeApprove(to, amount);
        }
    }

    function buyBackAndBurn(address lpToken, uint amount) public {

        require (amount > 0);
        require (maxBurnAndBuyBackAmounts[IBEP20(lpToken)] >= amount);
        address token0 = IPancakePair(lpToken).token0();
        address token1 = IPancakePair(lpToken).token1();
        (uint removed0, uint removed1) = router.removeLiquidity (token0, token1, amount, 1, 1, address(this), block.timestamp + 1 minutes);

        // If none are brush, first convert one of them to wftm as there's no guarentee there will be a brush pair with it.
        uint extraToSwap = 0;
        uint extraBrushToBurn = 0;
        uint deadline = block.timestamp + 10000;
        bool oneIsBrush = token0 == address(brush) || token1 == address(brush); 
        if (!oneIsBrush) {
            address[] memory path;
            path = new address[](2);
            path[0] = (token0 == address(wftm)) ? token1 : token0;
            path[1] = wftm;
            uint[] memory inOut = router.swapExactTokensForTokens(
                (token0 == address(wftm)) ? removed1 : removed0,
                0,
                path,
                address(this),
                deadline
            );
            extraToSwap = inOut[1];
        } else {
            extraBrushToBurn = token0 == address(brush) ? removed0 : removed1; 
        }

        // Buy back brush
        address[] memory path;
        path = new address[](2);
        path[0] = ((oneIsBrush && token0 == address(brush)) || (!oneIsBrush && token1 == wftm)) ? token1 : token0;
        path[1] = address(brush);
        uint[] memory inOutBrush = router.swapExactTokensForTokens(
            (((oneIsBrush && token0 == address(brush)) || (!oneIsBrush && token1 == wftm)) ? removed1 : removed0) + extraToSwap,
            0,
            path,
            address(this),
            deadline
        );

        // Decrement the maximum that can be burnt
        maxBurnAndBuyBackAmounts[IBEP20(lpToken)] -= amount;

        // Now burn it, reducing the total supply
        brush.burn(inOutBrush[1] + extraBrushToBurn);
    }

    function buyBackAndBurnAll(address lpToken) public {
        buyBackAndBurn(lpToken, maxBurnAndBuyBackAmounts[IBEP20(lpToken)]);
    }

    // Deposit LP tokens to Decorator for BRUSH allocation.
    function deposit(uint256 _pid, uint256 _amount) public {
        require (!depositsDisabled);
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accBrushPerShare).div(1e12).sub(user.rewardDebt);
            distributePendingRewards (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.accBrushPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from Decorator.
    function withdraw(uint256 _pid, uint256 _amount) public {
        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.accBrushPerShare).div(1e12).sub(user.rewardDebt);
        distributePendingRewards (pending);
        user.amount = user.amount.sub(_amount);
        uint256 withdrawFee = _withdraw (_pid, _amount, pool.lpToken);
        user.rewardDebt = user.amount.mul(pool.accBrushPerShare).div(1e12);
        emit Withdraw(msg.sender, _pid, _amount.sub (withdrawFee));
    }

    function enterStaking(uint256 _amount) public {
        deposit (0, _amount);
    }

    function leaveStaking(uint256 _amount) public {
        withdraw (0, _amount);
    }

    function _withdraw(uint _pid, uint _amount, IBEP20 _lpToken) internal returns (uint withdrawFee) {
        if (_amount > 0) {
            if (_pid == 0) {
                // Withdrawing from single sided staking incurs a withdrawal fee which is burnt.
                withdrawFee = _amount / inverseWithdrawFeeSingle;

                // Transfer first, then burn it
                _lpToken.safeTransfer(address(msg.sender), _amount);
                if (withdrawFee > 0) {
                    brush.burn (msg.sender, withdrawFee);
                }
            } else {
                // Withdrawing from other pools incurs a withdrawal fee. Any brush is burnt and the rest is used to buy-back brush and burn it.
                withdrawFee = _amount / inverseWithdrawFeeLP;

                _lpToken.safeTransfer(address(msg.sender), _amount - withdrawFee);
                maxBurnAndBuyBackAmounts[_lpToken] += withdrawFee;
            }
        }
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        uint256 amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;
        uint withdrawFee = _withdraw(_pid, amount, pool.lpToken);
        emit EmergencyWithdraw(msg.sender, _pid, amount - withdrawFee);
    }

    // Safe brush transfer function, just in case if rounding error causes pool to not have enough BRUSHs.
    function safeBrushTransfer(address _to, uint256 _amount) internal {
        uint256 brushBal = brush.balanceOf(address(this));
        if (_amount > brushBal) {
            brush.transfer(_to, brushBal);
        } else {
            brush.transfer(_to, _amount);
        }
    }

    function setBrushPerSecondEmissionRate(uint256 _brushPerSecond) public onlyOwner {
        // This MUST be done or pool rewards will be calculated with new boo per second.
        // This could unfairly punish small pools that dont have frequent deposits/withdraws/harvests.
        massUpdatePools();
        brushPerSecond = _brushPerSecond;
    }

    function setStartTime(uint256 _startTime) public onlyOwner {
        require (_startTime > block.timestamp);
        require (startTime > block.timestamp);
        startTime = _startTime;
        for (uint i = 0; i < poolInfo.length; ++i) {
            poolInfo[i].lastRewardTime = startTime;
        }
    }

    function setDepositsDisabled(bool _depositsDisabled) public onlyOwner {
        depositsDisabled = _depositsDisabled;
    }

    function setInverseWithdrawFeeLP(uint _inverseWithdrawFee) public onlyOwner {
        require (_inverseWithdrawFee > 0);
        inverseWithdrawFeeLP = _inverseWithdrawFee;
    }

    function setInverseWithdrawFeeSingle(uint _inverseWithdrawFee) public onlyOwner {
        require (_inverseWithdrawFee > 0);        
        inverseWithdrawFeeSingle = _inverseWithdrawFee;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract BrushToken","name":"_brush","type":"address"},{"internalType":"contract IArtGallery","name":"_artGallery","type":"address"},{"internalType":"contract IPancakeRouter02","name":"_router","type":"address"},{"internalType":"address","name":"_wftm","type":"address"},{"internalType":"uint256","name":"_brushPerSecond","type":"uint256"},{"internalType":"uint256","name":"_startTime","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":[{"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":[],"name":"artGallery","outputs":[{"internalType":"contract IArtGallery","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"brush","outputs":[{"internalType":"contract BrushToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"brushPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"lpToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"buyBackAndBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"lpToken","type":"address"}],"name":"buyBackAndBurnAll","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":"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":"_amount","type":"uint256"}],"name":"leaveStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IBEP20","name":"","type":"address"}],"name":"maxBurnAndBuyBackAmounts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingBrush","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_lpToken","type":"address"}],"name":"poolExists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accBrushPerShare","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":[],"name":"router","outputs":[{"internalType":"contract IPancakeRouter02","name":"","type":"address"}],"stateMutability":"view","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":[{"internalType":"uint256","name":"_brushPerSecond","type":"uint256"}],"name":"setBrushPerSecondEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_depositsDisabled","type":"bool"}],"name":"setDepositsDisabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_inverseWithdrawFee","type":"uint256"}],"name":"setInverseWithdrawFeeLP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_inverseWithdrawFee","type":"uint256"}],"name":"setInverseWithdrawFeeSingle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startTime","type":"uint256"}],"name":"setStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","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":"_pid","type":"uint256"}],"name":"updatePool","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":[],"name":"wftm","outputs":[{"internalType":"address","name":"","type":"address"}],"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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

00000000000000000000000085dec8c4b2680793661bca91a8f129607571863d0000000000000000000000009076c96e01f6f13e1ec4832354df970d245e124f000000000000000000000000fd000ddcea75a2e23059881c3589f6425bff1abb00000000000000000000000021be370d5312f44cb42ce377bc9b8a0cef1a4c83000000000000000000000000000000000000000000000000a1f42b2b70cf00000000000000000000000000000000000000000000000000000000000060aea8c0

-----Decoded View---------------
Arg [0] : _brush (address): 0x85dec8c4b2680793661bca91a8f129607571863d
Arg [1] : _artGallery (address): 0x9076c96e01f6f13e1ec4832354df970d245e124f
Arg [2] : _router (address): 0xfd000ddcea75a2e23059881c3589f6425bff1abb
Arg [3] : _wftm (address): 0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83
Arg [4] : _brushPerSecond (uint256): 11670000000000000000
Arg [5] : _startTime (uint256): 1622059200

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 00000000000000000000000085dec8c4b2680793661bca91a8f129607571863d
Arg [1] : 0000000000000000000000009076c96e01f6f13e1ec4832354df970d245e124f
Arg [2] : 000000000000000000000000fd000ddcea75a2e23059881c3589f6425bff1abb
Arg [3] : 00000000000000000000000021be370d5312f44cb42ce377bc9b8a0cef1a4c83
Arg [4] : 000000000000000000000000000000000000000000000000a1f42b2b70cf0000
Arg [5] : 0000000000000000000000000000000000000000000000000000000060aea8c0

48150:16045:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62988:354;;;;;;:::i;:::-;;:::i;:::-;;51953:95;52025:8;:15;51953:95;;;13121:25:1;;;13109:2;13094:18;51953:95:0;;;;;;;;61036:86;;;;;;:::i;:::-;;:::i;49982:26::-;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;8005:32:1;;;7987:51;;8069:2;8054:18;;8047:34;;;;8097:18;;;8090:34;8155:2;8140:18;;8133:34;7974:3;7959:19;49982:26:0;7941:232:1;50377:34:0;;;;;;52056:111;;;;;;:::i;:::-;-1:-1:-1;;;;;52140:19:0;52116:4;52140:19;;;:9;:19;;;;;;;;;52056:111;;;;7261:14:1;;7254:22;7236:41;;7224:2;7209:18;52056:111:0;7191:92:1;52274:1158:0;;;;;;:::i;:::-;;:::i;49859:29::-;;;;;-1:-1:-1;;;;;49859:29:0;;;;;;-1:-1:-1;;;;;5391:32:1;;;5373:51;;5361:2;5346:18;49859:29:0;5328:102:1;63350:315:0;;;;;;:::i;:::-;;:::i;60943:85::-;;;;;;:::i;:::-;;:::i;60260:675::-;;;;;;:::i;:::-;;:::i;49680:29::-;;;;;;49547:23;;;;;-1:-1:-1;;;;;49547:23:0;;;55464:772;;;;;;:::i;:::-;;:::i;62178:401::-;;;;;;:::i;:::-;;:::i;55208:180::-;;;:::i;53529:395::-;;;;;;:::i;:::-;;:::i;27962:148::-;;;:::i;63806:181::-;;;;;;:::i;:::-;;:::i;50466:24::-;;;;;;27320:79;27358:7;27385:6;-1:-1:-1;;;;;27385:6:0;27320:79;;50216:66;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14319:25:1;;;14375:2;14360:18;;14353:34;;;;14292:18;50216:66:0;14274:119:1;63995:197:0;;;;;;:::i;:::-;;:::i;59265:136::-;;;;;;:::i;:::-;;:::i;59470:739::-;;;;;;:::i;:::-;;:::i;63673:125::-;;;;;;:::i;:::-;;:::i;57137:2120::-;;;;;;:::i;:::-;;:::i;28265:244::-;;;;;;:::i;:::-;;:::i;49611:19::-;;;;;-1:-1:-1;;;;;49611:19:0;;;49916:30;;;;;-1:-1:-1;;;;;49916:30:0;;;54346:779;;;;;;:::i;:::-;;:::i;50555:56::-;;;;;;:::i;:::-;;;;;;;;;;;;;;62988:354;27532:6;;-1:-1:-1;;;;;27532:6:0;6026:10;27532:22;27524:67;;;;-1:-1:-1;;;27524:67:0;;;;;;;:::i;:::-;;;;;;;;;63274:17:::1;:15;:17::i;:::-;63302:14;:32:::0;62988:354::o;61036:86::-;61093:21;61103:1;61106:7;61093:8;:21::i;:::-;61036:86;:::o;49982:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;49982:26:0;;;;-1:-1:-1;49982:26:0;;;:::o;52274:1158::-;27532:6;;-1:-1:-1;;;;;27532:6:0;6026:10;27532:22;27524:67;;;;-1:-1:-1;;;27524:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;52140:19:0;;52116:4;52140:19;;;:9;:19;;;;;;;;52380:30:::1;52371:69;;;::::0;-1:-1:-1;;;52371:69:0;;9000:2:1;52371:69:0::1;::::0;::::1;8982:21:1::0;9039:2;9019:18;;;9012:30;9078:27;9058:18;;;9051:55;9123:18;;52371:69:0::1;8972:175:1::0;52371:69:0::1;52451:14;52489:8;-1:-1:-1::0;;;;;52468:38:0::1;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52451:57;;52519:14;52557:8;-1:-1:-1::0;;;;;52536:38:0::1;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52614:5;::::0;52519:57;;-1:-1:-1;;;;;;52596:24:0;;::::1;52614:5:::0;::::1;52596:24;::::0;:52:::1;;-1:-1:-1::0;52642:5:0::1;::::0;-1:-1:-1;;;;;52624:24:0;;::::1;52642:5:::0;::::1;52624:24;52596:52;:70;;;-1:-1:-1::0;52662:4:0::1;::::0;-1:-1:-1;;;;;52652:14:0;;::::1;52662:4:::0;::::1;52652:14;52596:70;:88;;;-1:-1:-1::0;52680:4:0::1;::::0;-1:-1:-1;;;;;52670:14:0;;::::1;52680:4:::0;::::1;52670:14;52596:88;52587:98;;;::::0;::::1;;52700:11;52696:61;;;52728:17;:15;:17::i;:::-;52767:22;52810:9;;52792:15;:27;:57;;52840:9;;52792:57;;;52822:15;52792:57;52878:15;::::0;52767:82;;-1:-1:-1;52878:32:0::1;::::0;52898:11;52878:19:::1;:32::i;:::-;52860:15;:50:::0;52935:170:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;52935:170:0;;::::1;::::0;;;::::1;::::0;;::::1;::::0;;;;;;;;;-1:-1:-1;52935:170:0;;;;;;52921:8:::1;:185:::0;;::::1;::::0;;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;;::::1;-1:-1:-1::0;;;;;;52921:185:0;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;;;53119:3:::1;:34:::0;;;;::::1;::::0;;;;::::1;::::0;;;;::::1;::::0;::::1;::::0;;;53164:28;;;:9;:28;;;;;;:35;;-1:-1:-1;;53164:35:0::1;::::0;;::::1;::::0;;-1:-1:-1;53246:6:0;53210:60:::1;::::0;52968:8;;53246:6:::1;-1:-1:-1::0;;53210:16:0::1;:60::i;:::-;53323:6;::::0;53281:66:::1;::::0;53306:6;;-1:-1:-1;;;;;53323:6:0::1;-1:-1:-1::0;;53281:16:0::1;:66::i;:::-;53400:6;::::0;53358:66:::1;::::0;53383:6;;-1:-1:-1;;;;;53400:6:0::1;-1:-1:-1::0;;53358:16:0::1;:66::i;:::-;27602:1;;;52274:1158:::0;;;:::o;63350:315::-;27532:6;;-1:-1:-1;;;;;27532:6:0;6026:10;27532:22;27524:67;;;;-1:-1:-1;;;27524:67:0;;;;;;;:::i;:::-;63442:15:::1;63429:10;:28;63420:38;;;::::0;::::1;;63490:15;63478:9;;:27;63469:37;;;::::0;::::1;;63517:9;:22:::0;;;63555:6:::1;63550:108;63571:8;:15:::0;63567:19;::::1;63550:108;;;63637:9;;63608:8;63617:1;63608:11;;;;;;-1:-1:-1::0;;;63608:11:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;:26:::1;:11;::::0;;::::1;;:26;:38:::0;63588:3:::1;::::0;::::1;:::i;:::-;;;63550:108;;;;63350:315:::0;:::o;60943:85::-;61000:20;61009:1;61012:7;61000;:20::i;60260:675::-;60327:21;60351:8;60360:4;60351:14;;;;;;-1:-1:-1;;;60351:14:0;;;;;;;;;;;;;;;;;60400;;;:8;:14;;;;;;60415:10;60400:26;;;;;;;60445:11;;60351:14;;;;;;;;-1:-1:-1;60445:22:0;-1:-1:-1;60445:22:0;60437:53;;;;-1:-1:-1;;;60437:53:0;;12830:2:1;60437:53:0;;;12812:21:1;12869:2;12849:18;;;12842:30;-1:-1:-1;;;12888:18:1;;;12881:48;12946:18;;60437:53:0;12802:168:1;60437:53:0;60501:16;60512:4;60501:10;:16::i;:::-;60528:15;60546:69;60599:4;:15;;;60546:48;60589:4;60546:38;60562:4;:21;;;60546:4;:11;;;:15;;:38;;;;:::i;:::-;:42;;:48::i;:::-;:52;;:69::i;:::-;60528:87;;60626:34;60652:7;60626:24;:34::i;:::-;60685:11;;:24;;60701:7;60685:15;:24::i;:::-;60671:38;;60768:12;;60671:11;;60742:39;;60753:4;;60759:7;;-1:-1:-1;;;;;60768:12:0;60742:9;:39::i;:::-;60720:61;;60810:48;60853:4;60810:38;60826:4;:21;;;60810:4;:11;;;:15;;:38;;;;:::i;:48::-;60792:15;;;:66;60895:4;60883:10;60874:53;60901:25;:7;60914:11;60901;:25::i;:::-;60874:53;;13121:25:1;;;13109:2;13094:18;60874:53:0;;;;;;;60260:675;;;;;;:::o;55464:772::-;55516:21;55540:8;55549:4;55540:14;;;;;;-1:-1:-1;;;55540:14:0;;;;;;;;;;;;;;;;;;;55516:38;;55588:4;:19;;;55569:15;:38;55565:77;;55624:7;55464:772;:::o;55565:77::-;55671:12;;:37;;-1:-1:-1;;;55671:37:0;;55702:4;55671:37;;;5373:51:1;55652:16:0;;-1:-1:-1;;;;;55671:12:0;;:22;;5346:18:1;;55671:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55652:56;-1:-1:-1;55723:13:0;;;:37;;-1:-1:-1;55740:15:0;;;;:20;55723:37;55719:128;;;-1:-1:-1;55799:15:0;55777:19;;;;:37;-1:-1:-1;55464:772:0:o;55719:128::-;55857:18;55878:51;55892:4;:19;;;55913:15;55878:13;:51::i;:::-;55857:72;;55940:19;55962:72;56018:15;;55962:51;55997:4;:15;;;55962:30;55977:14;;55962:10;:14;;:30;;;;:::i;:::-;:34;;:51::i;:72::-;56045:5;;:38;;-1:-1:-1;;;56045:38:0;;56064:4;56045:38;;;6991:51:1;7058:18;;;7051:34;;;55940:94:0;;-1:-1:-1;;;;;;56045:5:0;;:10;;6964:18:1;;56045:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56118:62;56144:35;56170:8;56144:21;56160:4;56144:11;:15;;:21;;;;:::i;:35::-;56118:21;;;;;:25;:62::i;:::-;56094:21;;;:86;-1:-1:-1;;56213:15:0;56191:19;;;;:37;;;;-1:-1:-1;;55464:772:0:o;62178:401::-;62237:21;62261:8;62270:4;62261:14;;;;;;-1:-1:-1;;;62261:14:0;;;;;;;;;;;;;;;;;62310;;;:8;:14;;;;;;62325:10;62310:26;;;;;;;;62364:11;;62386:15;;;-1:-1:-1;62412:15:0;;:19;;;62261:14;;;;;;;62485:12;;62261:14;;-1:-1:-1;62310:26:0;;62261:14;62461:37;;62319:4;;62364:11;;-1:-1:-1;;;;;62485:12:0;62461:9;:37::i;:::-;62442:56;-1:-1:-1;62544:4:0;62532:10;62514:57;62550:20;62442:56;62550:6;:20;:::i;:::-;62514:57;;13121:25:1;;;13109:2;13094:18;62514:57:0;;;;;;;62178:401;;;;;:::o;55208:180::-;55270:8;:15;55253:14;55296:85;55324:6;55318:3;:12;55296:85;;;55354:15;55365:3;55354:10;:15::i;:::-;55332:5;;;:::i;:::-;;;55296:85;;53529:395;27532:6;;-1:-1:-1;;;;;27532:6:0;6026:10;27532:22;27524:67;;;;-1:-1:-1;;;27524:67:0;;;;;;;:::i;:::-;53632:44:::1;53652:8;53661:4;53652:14;;;;;;-1:-1:-1::0;;;53652:14:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;::::0;;::::1;:22:::0;-1:-1:-1;;;;;53652:22:0::1;52140:19:::0;;:9;:19;;;;;;;;;52056:111;53632:44:::1;53623:80;;;::::0;-1:-1:-1;;;53623:80:0;;10528:2:1;53623:80:0::1;::::0;::::1;10510:21:1::0;10567:2;10547:18;;;10540:30;-1:-1:-1;;;10586:18:1;;;10579:52;10648:18;;53623:80:0::1;10500:172:1::0;53623:80:0::1;53718:11;53714:61;;;53746:17;:15;:17::i;:::-;53803:63;53854:11;53803:46;53823:8;53832:4;53823:14;;;;;;-1:-1:-1::0;;;53823:14:0::1;;;;;;;;;;;;;;;;;;;:25;;;53803:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:63::i;:::-;53785:15;:81;;;;53905:11;53877:8;53886:4;53877:14;;;;;;-1:-1:-1::0;;;53877:14:0::1;;;;;;;;;;;;;;;;;;;:25;;:39;;;;53529:395:::0;;;:::o;27962:148::-;27532:6;;-1:-1:-1;;;;;27532:6:0;6026:10;27532:22;27524:67;;;;-1:-1:-1;;;27524:67:0;;;;;;;:::i;:::-;28069:1:::1;28053:6:::0;;28032:40:::1;::::0;-1:-1:-1;;;;;28053:6:0;;::::1;::::0;28032:40:::1;::::0;28069:1;;28032:40:::1;28100:1;28083:19:::0;;-1:-1:-1;;;;;;28083:19:0::1;::::0;;27962:148::o;63806:181::-;27532:6;;-1:-1:-1;;;;;27532:6:0;6026:10;27532:22;27524:67;;;;-1:-1:-1;;;27524:67:0;;;;;;;:::i;:::-;63924:1:::1;63902:19;:23;63893:33;;;::::0;::::1;;63937:20;:42:::0;63806:181::o;63995:197::-;27532:6;;-1:-1:-1;;;;;27532:6:0;6026:10;27532:22;27524:67;;;;-1:-1:-1;;;27524:67:0;;;;;;;:::i;:::-;64117:1:::1;64095:19;:23;64086:33;;;::::0;::::1;;64138:24;:46:::0;63995:197::o;59265:136::-;-1:-1:-1;;;;;59351:41:0;;;;;;:24;:41;;;;;;59327:66;;59342:7;;59327:14;:66::i;59470:739::-;59546:16;;;;59545:17;59536:27;;;;;;59574:21;59598:8;59607:4;59598:14;;;;;;-1:-1:-1;;;59598:14:0;;;;;;;;;;;;;;;;;59647;;;:8;:14;;;;;;59662:10;59647:26;;;;;;;59598:14;;;;;;;;-1:-1:-1;59684:16:0;59656:4;59684:10;:16::i;:::-;59715:11;;:15;59711:184;;59747:15;59765:69;59818:4;:15;;;59765:48;59808:4;59765:38;59781:4;:21;;;59765:4;:11;;;:15;;:38;;;;:::i;:69::-;59747:87;;59849:34;59875:7;59849:24;:34::i;:::-;59711:184;;59908:11;;59905:170;;59936:12;;:74;;-1:-1:-1;;;;;59936:12:0;59974:10;59995:4;60002:7;59936:29;:74::i;:::-;60039:11;;:24;;60055:7;60039:15;:24::i;:::-;60025:38;;59905:170;60119:21;;;;60103:11;;:48;;60146:4;;60103:38;;:15;:38::i;:48::-;60085:15;;;:66;60167:34;;13121:25:1;;;60187:4:0;;60175:10;;60167:34;;13109:2:1;13094:18;60167:34:0;;;;;;;59470:739;;;;:::o;63673:125::-;27532:6;;-1:-1:-1;;;;;27532:6:0;6026:10;27532:22;27524:67;;;;-1:-1:-1;;;27524:67:0;;;;;;;:::i;:::-;63754:16:::1;:36:::0;;-1:-1:-1;;63754:36:0::1;::::0;::::1;;::::0;;;::::1;::::0;;63673:125::o;57137:2120::-;57229:1;57220:6;:10;57211:20;;;;;;-1:-1:-1;;;;;57251:41:0;;;;;;:24;:41;;;;;;:51;-1:-1:-1;57251:51:0;57242:61;;;;;;57314:14;57344:7;-1:-1:-1;;;;;57331:28:0;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57314:47;;57372:14;57402:7;-1:-1:-1;;;;;57389:28:0;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57463:6;;57372:47;;-1:-1:-1;57431:13:0;;;;-1:-1:-1;;;;;57463:6:0;:22;57487:6;57372:47;57503:6;57463;;57525:4;57532:27;:15;57550:9;57532:27;:::i;:::-;57463:97;;;;;;-1:-1:-1;;;;;;57463:97:0;;;-1:-1:-1;;;;;6511:15:1;;;57463:97:0;;;6493:34:1;6563:15;;;6543:18;;;6536:43;6595:18;;;6588:34;;;;6638:18;;;6631:34;;;;6681:19;;;6674:35;6746:15;;;6725:19;;;6718:44;6778:19;;;6771:35;;;;6427:19;;57463:97:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57430:130;;-1:-1:-1;57430:130:0;-1:-1:-1;57698:16:0;;;57781:23;:15;57799:5;57781:23;:::i;:::-;57851:5;;57765:39;;-1:-1:-1;57815:15:0;;-1:-1:-1;;;;;57833:24:0;;;57851:5;;57833:24;;:52;;-1:-1:-1;57879:5:0;;-1:-1:-1;;;;;57861:24:0;;;57879:5;;57861:24;57833:52;57815:70;;57902:10;57897:587;;57972:16;;;57986:1;57972:16;;;57929:21;57972:16;;;;;57929:21;57972:16;;;;;;;;;;-1:-1:-1;;58032:4:0;;57965:23;;-1:-1:-1;;;;;;58014:23:0;;;58032:4;;58014:23;58013:43;;58050:6;58013:43;;;58041:6;58013:43;58003:4;58008:1;58003:7;;;;;;-1:-1:-1;;;58003:7:0;;;;;;;;;-1:-1:-1;;;;;58003:53:0;;;:7;;;;;;;;;:53;58081:4;;58071:7;;58081:4;;;58071;;58081;;58071:7;;;;-1:-1:-1;;;58071:7:0;;;;;;;;;-1:-1:-1;;;;;58071:14:0;;;:7;;;;;;;;;:14;58122:6;;58191:4;;58100:19;;58122:6;;;;:31;;58173:23;;;58191:4;;58173:23;58172:47;;58211:8;58172:47;;;58200:8;58172:47;58238:1;58258:4;58289;58313:8;58122:214;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;58122:214:0;;;;;;;;;;;;:::i;:::-;58100:236;;58365:5;58371:1;58365:8;;;;;;-1:-1:-1;;;58365:8:0;;;;;;;;;;;;;;;58351:22;;57897:587;;;;;58443:5;;-1:-1:-1;;;;;58425:24:0;;;58443:5;;58425:24;:46;;58463:8;58425:46;;;58452:8;58425:46;58406:65;;57897:587;58562:16;;;58576:1;58562:16;;;58523:21;58562:16;;;;;58523:21;58562:16;;;;;;;;;;-1:-1:-1;58562:16:0;58555:23;;58601:10;:38;;;;-1:-1:-1;58633:5:0;;-1:-1:-1;;;;;58615:24:0;;;58633:5;;58615:24;58601:38;58600:75;;;;58646:10;58645:11;:29;;;;-1:-1:-1;58670:4:0;;-1:-1:-1;;;;;58660:14:0;;;58670:4;;58660:14;58645:29;58599:95;;58688:6;58599:95;;;58679:6;58599:95;58589:4;58594:1;58589:7;;;;;;-1:-1:-1;;;58589:7:0;;;;;;;;;-1:-1:-1;;;;;58589:105:0;;;:7;;;;;;;;;:105;58723:5;;;58705:7;;58723:5;;;58705:4;;58723:5;58705:7;;;;-1:-1:-1;;;58705:7:0;;;;;;;;;-1:-1:-1;;;;;58705:24:0;;;:7;;;;;;;;;:24;58767:6;;58740:24;;58767:6;:31;58917:11;58816:10;:38;;;;-1:-1:-1;58848:5:0;;-1:-1:-1;;;;;58830:24:0;;;58848:5;;58830:24;58816:38;58815:75;;;;58861:10;58860:11;:29;;;;-1:-1:-1;58885:4:0;;-1:-1:-1;;;;;58875:14:0;;;58885:4;;58875:14;58860:29;58814:99;;58905:8;58814:99;;;58894:8;58814:99;58813:115;;;;:::i;:::-;58943:1;58959:4;58986;59006:8;58767:258;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;58767:258:0;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;59090:41:0;;;;;;:24;:41;;;;;:51;;58740:285;;-1:-1:-1;59135:6:0;;59090:41;;;:51;;59135:6;;59090:51;:::i;:::-;;;;-1:-1:-1;;59205:5:0;;;59216:13;;-1:-1:-1;;;;;59205:5:0;;;;:10;;59232:16;;59216:10;;:13;;;;-1:-1:-1;;;59216:13:0;;;;;;;;;;;;;;;:32;;;;:::i;:::-;59205:44;;;;;;;;;;;;;13121:25:1;;13109:2;13094:18;;13076:76;59205:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57137:2120;;;;;;;;;;;;:::o;28265:244::-;27532:6;;-1:-1:-1;;;;;27532:6:0;6026:10;27532:22;27524:67;;;;-1:-1:-1;;;27524:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;28354:22:0;::::1;28346:73;;;::::0;-1:-1:-1;;;28346:73:0;;9765:2:1;28346:73:0::1;::::0;::::1;9747:21:1::0;9804:2;9784:18;;;9777:30;9843:34;9823:18;;;9816:62;-1:-1:-1;;;9894:18:1;;;9887:36;9940:19;;28346:73:0::1;9737:228:1::0;28346:73:0::1;28456:6;::::0;;28435:38:::1;::::0;-1:-1:-1;;;;;28435:38:0;;::::1;::::0;28456:6;::::1;::::0;28435:38:::1;::::0;::::1;28484:6;:17:::0;;-1:-1:-1;;;;;;28484:17:0::1;-1:-1:-1::0;;;;;28484:17:0;;;::::1;::::0;;;::::1;::::0;;28265:244::o;54346:779::-;54420:7;54440:21;54464:8;54473:4;54464:14;;;;;;-1:-1:-1;;;54464:14:0;;;;;;;;;;;;;;;;;54513;;;:8;:14;;;;;;-1:-1:-1;;;;;54513:21:0;;;;;;;;;;54464:14;;;;;;;54572:21;;;;54623:12;;:37;;-1:-1:-1;;;54623:37:0;;54654:4;54623:37;;;5373:51:1;;;;54464:14:0;;-1:-1:-1;54513:21:0;;54572;;54464:14;;54623:12;;:22;;5346:18:1;;54623:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54604:56;;54693:4;:19;;;54675:15;:37;:54;;;;-1:-1:-1;54716:13:0;;;54675:54;54671:359;;;54746:18;54767:51;54781:4;:19;;;54802:15;54767:13;:51::i;:::-;54746:72;;54833:19;54855:72;54911:15;;54855:51;54890:4;:15;;;54855:30;54870:14;;54855:10;:14;;:30;;;;:::i;:72::-;54833:94;-1:-1:-1;54961:57:0;54982:35;55008:8;54982:21;54833:94;54998:4;54982:15;:21::i;:35::-;54961:16;;:20;:57::i;:::-;54942:76;;54671:359;;;55116:1;55048:64;55096:4;:15;;;55048:43;55086:4;55048:33;55064:16;55048:4;:11;;;:15;;:33;;;;:::i;:64::-;55047:70;;;;:::i;:::-;55040:77;;;;;;54346:779;;;;;:::o;23890:622::-;24260:10;;;24259:62;;-1:-1:-1;24276:39:0;;-1:-1:-1;;;24276:39:0;;24300:4;24276:39;;;5647:34:1;-1:-1:-1;;;;;5717:15:1;;;5697:18;;;5690:43;24276:15:0;;;;;5582:18:1;;24276:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;24259:62;24251:152;;;;-1:-1:-1;;;24251:152:0;;11688:2:1;24251:152:0;;;11670:21:1;11727:2;11707:18;;;11700:30;11766:34;11746:18;;;11739:62;-1:-1:-1;;;11817:18:1;;;11810:52;11879:19;;24251:152:0;11660:244:1;24251:152:0;24441:62;;-1:-1:-1;;;;;7009:32:1;;24441:62:0;;;6991:51:1;7058:18;;;7051:34;;;24414:90:0;;24434:5;;-1:-1:-1;;;24464:22:0;6964:18:1;;24441:62:0;;;;-1:-1:-1;;24441:62:0;;;;;;;;;;;;;;-1:-1:-1;;;;;24441:62:0;-1:-1:-1;;;;;;24441:62:0;;;;;;;;;;24414:19;:90::i;:::-;23890:622;;;:::o;19333:195::-;19436:12;19468:52;19490:6;19498:4;19504:1;19507:12;19468:21;:52::i;:::-;19461:59;;19333:195;;;;;;:::o;928:181::-;986:7;;1018:5;1022:1;1018;:5;:::i;:::-;1006:17;;1047:1;1042;:6;;1034:46;;;;-1:-1:-1;;;1034:46:0;;10172:2:1;1034:46:0;;;10154:21:1;10211:2;10191:18;;;10184:30;10250:29;10230:18;;;10223:57;10297:18;;1034:46:0;10144:177:1;56696:433:0;56788:11;56784:89;;56816:24;-1:-1:-1;;;;;56816:17:0;;56834:2;56838:1;56816:17;:24::i;56784:89::-;56905:34;;-1:-1:-1;;;56905:34:0;;56929:4;56905:34;;;5647::1;-1:-1:-1;;;;;5717:15:1;;;5697:18;;;5690:43;56885:17:0;;56905:15;;;;;;5582:18:1;;56905:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56885:54;;56966:6;56954:9;:18;56950:172;;;56993:13;;56989:78;;57027:24;-1:-1:-1;;;;;57027:17:0;;57045:2;57049:1;57027:17;:24::i;:::-;57081:29;-1:-1:-1;;;;;57081:17:0;;57099:2;57103:6;57081:17;:29::i;:::-;56696:433;;;;:::o;2282:471::-;2340:7;2585:6;2581:47;;-1:-1:-1;2615:1:0;2608:8;;2581:47;2640:9;2652:5;2656:1;2652;:5;:::i;:::-;2640:17;-1:-1:-1;2685:1:0;2676:5;2680:1;2640:17;2676:5;:::i;:::-;:10;2668:56;;;;-1:-1:-1;;;2668:56:0;;11286:2:1;2668:56:0;;;11268:21:1;11325:2;11305:18;;;11298:30;11364:34;11344:18;;;11337:62;-1:-1:-1;;;11415:18:1;;;11408:31;11456:19;;2668:56:0;11258:223:1;3229:132:0;3287:7;3314:39;3318:1;3321;3314:39;;;;;;;;;;;;;;;;;:3;:39::i;1392:136::-;1450:7;1477:43;1481:1;1484;1477:43;;;;;;;;;;;;;;;;;:3;:43::i;56244:444::-;56319:12;;56315:366;;56388:19;56410:12;56421:1;56410:8;:12;:::i;:::-;56388:34;;56452:1;56441:8;:12;56437:163;;;56474:10;;;:40;;-1:-1:-1;;;56474:40:0;;56490:10;56474:40;;;6991:51:1;;;;7058:18;;;7051:34;;;-1:-1:-1;;;;;56474:10:0;;:15;;6964:18:1;;56474:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;56559:10:0;;56533:51;;-1:-1:-1;;;;;;56559:10:0;;-1:-1:-1;56572:11:0;56533:17;:51::i;:::-;56616:53;56634:10;56646:22;56657:11;56646:8;:22;:::i;:::-;56616:17;:53::i;61130:977::-;61209:16;61242:11;;61238:862;;61274:9;61270:819;;61426:24;;61416:34;;:7;:34;:::i;:::-;61402:48;-1:-1:-1;61520:51:0;-1:-1:-1;;;;;61520:21:0;;61550:10;61563:7;61520:21;:51::i;:::-;61594:15;;61590:100;;61634:5;;:36;;-1:-1:-1;;;61634:36:0;;61646:10;61634:36;;;6991:51:1;7058:18;;;7051:34;;;-1:-1:-1;;;;;61634:5:0;;;;:10;;6964:18:1;;61634:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61590:100;61270:819;;;61899:20;;61889:30;;:7;:30;:::i;:::-;61875:44;-1:-1:-1;61940:65:0;61970:10;61983:21;61875:44;61983:7;:21;:::i;:::-;-1:-1:-1;;;;;61940:21:0;;;:65;:21;:65::i;:::-;-1:-1:-1;;;;;62024:34:0;;;;;;:24;:34;;;;;:49;;62062:11;;62024:34;:49;;62062:11;;62024:49;:::i;:::-;;;;-1:-1:-1;;61130:977:0;;;;;:::o;53999:186::-;54073:7;54103:9;;54097:3;:15;54093:56;;;-1:-1:-1;54136:1:0;54129:8;;54093:56;54166:11;54172:5;54166:3;:11;:::i;23416:205::-;23544:68;;-1:-1:-1;;;;;6002:15:1;;;23544:68:0;;;5984:34:1;6054:15;;6034:18;;;6027:43;6086:18;;;6079:34;;;23517:96:0;;23537:5;;-1:-1:-1;;;23567:27:0;5919:18:1;;23544:68:0;5901:218:1;25536:761:0;25960:23;25986:69;26014:4;25986:69;;;;;;;;;;;;;;;;;25994:5;-1:-1:-1;;;;;25986:27:0;;;:69;;;;;:::i;:::-;26070:17;;25960:95;;-1:-1:-1;26070:21:0;26066:224;;26212:10;26201:30;;;;;;;;;;;;:::i;:::-;26193:85;;;;-1:-1:-1;;;26193:85:0;;9354:2:1;26193:85:0;;;9336:21:1;9393:2;9373:18;;;9366:30;9432:34;9412:18;;;9405:62;-1:-1:-1;;;9483:18:1;;;9476:40;9533:19;;26193:85:0;9326:232:1;20385:530:0;20512:12;20570:5;20545:21;:30;;20537:81;;;;-1:-1:-1;;;20537:81:0;;10879:2:1;20537:81:0;;;10861:21:1;10918:2;10898:18;;;10891:30;10957:34;10937:18;;;10930:62;-1:-1:-1;;;11008:18:1;;;11001:36;11054:19;;20537:81:0;10851:228:1;20537:81:0;16782:20;;20629:60;;;;-1:-1:-1;;;20629:60:0;;12472:2:1;20629:60:0;;;12454:21:1;12511:2;12491:18;;;12484:30;12550:31;12530:18;;;12523:59;12599:18;;20629:60:0;12444:179:1;20629:60:0;20763:12;20777:23;20804:6;-1:-1:-1;;;;;20804:11:0;20824:5;20832:4;20804:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20762:75;;;;20855:52;20873:7;20882:10;20894:12;20855:17;:52::i;:::-;20848:59;20385:530;-1:-1:-1;;;;;;;20385:530:0:o;3857:278::-;3943:7;3978:12;3971:5;3963:28;;;;-1:-1:-1;;;3963:28:0;;;;;;;;:::i;:::-;-1:-1:-1;4002:9:0;4014:5;4018:1;4014;:5;:::i;:::-;4002:17;3857:278;-1:-1:-1;;;;;3857:278:0:o;1831:192::-;1917:7;1953:12;1945:6;;;;1937:29;;;;-1:-1:-1;;;1937:29:0;;;;;;;;:::i;:::-;-1:-1:-1;1977:9:0;1989:5;1993:1;1989;:5;:::i;62695:285::-;62791:5;;:30;;-1:-1:-1;;;62791:30:0;;62815:4;62791:30;;;5373:51:1;62772:16:0;;-1:-1:-1;;;;;62791:5:0;;:15;;5346:18:1;;62791:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62772:49;;62846:8;62836:7;:18;62832:141;;;62871:5;;:29;;-1:-1:-1;;;62871:29:0;;-1:-1:-1;;;;;7009:32:1;;;62871:29:0;;;6991:51:1;7058:18;;;7051:34;;;62871:5:0;;;;:14;;6964:18:1;;62871:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;62832:141::-;62933:5;;:28;;-1:-1:-1;;;62933:28:0;;-1:-1:-1;;;;;7009:32:1;;;62933:28:0;;;6991:51:1;7058:18;;;7051:34;;;62933:5:0;;;;:14;;6964:18:1;;62933:28:0;6946:145:1;23231:177:0;23341:58;;-1:-1:-1;;;;;7009:32:1;;23341:58:0;;;6991:51:1;7058:18;;;7051:34;;;23314:86:0;;23334:5;;-1:-1:-1;;;23364:23:0;6964:18:1;;23341:58:0;6946:145:1;21921:742:0;22036:12;22065:7;22061:595;;;-1:-1:-1;22096:10:0;22089:17;;22061:595;22210:17;;:21;22206:439;;22473:10;22467:17;22534:15;22521:10;22517:2;22513:19;22506:44;22421:148;22616:12;22609:20;;-1:-1:-1;;;22609:20:0;;;;;;;;:::i;14:257:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:2;;;147:6;139;132:22;94:2;191:9;178:23;210:31;235:5;210:31;:::i;276:261::-;346:6;399:2;387:9;378:7;374:23;370:32;367:2;;;420:6;412;405:22;367:2;457:9;451:16;476:31;501:5;476:31;:::i;542:325::-;610:6;618;671:2;659:9;650:7;646:23;642:32;639:2;;;692:6;684;677:22;639:2;736:9;723:23;755:31;780:5;755:31;:::i;:::-;805:5;857:2;842:18;;;;829:32;;-1:-1:-1;;;629:238:1:o;872:1161::-;967:6;998:2;1041;1029:9;1020:7;1016:23;1012:32;1009:2;;;1062:6;1054;1047:22;1009:2;1100:9;1094:16;1129:18;1170:2;1162:6;1159:14;1156:2;;;1191:6;1183;1176:22;1156:2;1234:6;1223:9;1219:22;1209:32;;1279:7;1272:4;1268:2;1264:13;1260:27;1250:2;;1306:6;1298;1291:22;1250:2;1340;1334:9;1362:2;1358;1355:10;1352:2;;;1368:18;;:::i;:::-;1414:2;1411:1;1407:10;1446:2;1440:9;1509:2;1505:7;1500:2;1496;1492:11;1488:25;1480:6;1476:38;1564:6;1552:10;1549:22;1544:2;1532:10;1529:18;1526:46;1523:2;;;1575:18;;:::i;:::-;1611:2;1604:22;1661:18;;;1695:15;;;;-1:-1:-1;1730:11:1;;;1760;;;1756:20;;1753:33;-1:-1:-1;1750:2:1;;;1804:6;1796;1789:22;1750:2;1831:6;1822:15;;1846:156;1860:2;1857:1;1854:9;1846:156;;;1917:10;;1905:23;;1878:1;1871:9;;;;;1948:12;;;;1980;;1846:156;;;-1:-1:-1;2021:6:1;978:1055;-1:-1:-1;;;;;;;;978:1055:1:o;2038:251::-;2094:6;2147:2;2135:9;2126:7;2122:23;2118:32;2115:2;;;2168:6;2160;2153:22;2115:2;2212:9;2199:23;2231:28;2253:5;2231:28;:::i;2294:255::-;2361:6;2414:2;2402:9;2393:7;2389:23;2385:32;2382:2;;;2435:6;2427;2420:22;2382:2;2472:9;2466:16;2491:28;2513:5;2491:28;:::i;2830:190::-;2889:6;2942:2;2930:9;2921:7;2917:23;2913:32;2910:2;;;2963:6;2955;2948:22;2910:2;-1:-1:-1;2991:23:1;;2900:120;-1:-1:-1;2900:120:1:o;3025:194::-;3095:6;3148:2;3136:9;3127:7;3123:23;3119:32;3116:2;;;3169:6;3161;3154:22;3116:2;-1:-1:-1;3197:16:1;;3106:113;-1:-1:-1;3106:113:1:o;3224:325::-;3292:6;3300;3353:2;3341:9;3332:7;3328:23;3324:32;3321:2;;;3374:6;3366;3359:22;3321:2;3415:9;3402:23;3392:33;;3475:2;3464:9;3460:18;3447:32;3488:31;3513:5;3488:31;:::i;:::-;3538:5;3528:15;;;3311:238;;;;;:::o;3554:474::-;3642:6;3650;3658;3711:2;3699:9;3690:7;3686:23;3682:32;3679:2;;;3732:6;3724;3717:22;3679:2;3773:9;3760:23;3750:33;;3833:2;3822:9;3818:18;3805:32;3846:31;3871:5;3846:31;:::i;:::-;3896:5;-1:-1:-1;3953:2:1;3938:18;;3925:32;3966:30;3925:32;3966:30;:::i;:::-;4015:7;4005:17;;;3669:359;;;;;:::o;4033:258::-;4101:6;4109;4162:2;4150:9;4141:7;4137:23;4133:32;4130:2;;;4183:6;4175;4168:22;4130:2;-1:-1:-1;;4211:23:1;;;4281:2;4266:18;;;4253:32;;-1:-1:-1;4120:171:1:o;4296:255::-;4375:6;4383;4436:2;4424:9;4415:7;4411:23;4407:32;4404:2;;;4457:6;4449;4442:22;4404:2;-1:-1:-1;;4485:16:1;;4541:2;4526:18;;;4520:25;4485:16;;4520:25;;-1:-1:-1;4394:157:1:o;4556:387::-;4630:6;4638;4646;4699:2;4687:9;4678:7;4674:23;4670:32;4667:2;;;4720:6;4712;4705:22;4667:2;4761:9;4748:23;4738:33;;4818:2;4807:9;4803:18;4790:32;4780:42;;4872:2;4861:9;4857:18;4844:32;4885:28;4907:5;4885:28;:::i;4948:274::-;5077:3;5115:6;5109:13;5131:53;5177:6;5172:3;5165:4;5157:6;5153:17;5131:53;:::i;:::-;5200:16;;;;;5085:137;-1:-1:-1;;5085:137:1:o;8410:383::-;8559:2;8548:9;8541:21;8522:4;8591:6;8585:13;8634:6;8629:2;8618:9;8614:18;8607:34;8650:66;8709:6;8704:2;8693:9;8689:18;8684:2;8676:6;8672:15;8650:66;:::i;:::-;8777:2;8756:15;-1:-1:-1;;8752:29:1;8737:45;;;;8784:2;8733:54;;8531:262;-1:-1:-1;;8531:262:1:o;11909:356::-;12111:2;12093:21;;;12130:18;;;12123:30;12189:34;12184:2;12169:18;;12162:62;12256:2;12241:18;;12083:182::o;13157:983::-;13419:4;13467:3;13456:9;13452:19;13498:6;13487:9;13480:25;13524:2;13562:6;13557:2;13546:9;13542:18;13535:34;13605:3;13600:2;13589:9;13585:18;13578:31;13629:6;13664;13658:13;13695:6;13687;13680:22;13733:3;13722:9;13718:19;13711:26;;13772:2;13764:6;13760:15;13746:29;;13793:4;13806:195;13820:6;13817:1;13814:13;13806:195;;;13885:13;;-1:-1:-1;;;;;13881:39:1;13869:52;;13976:15;;;;13941:12;;;;13917:1;13835:9;13806:195;;;-1:-1:-1;;;;;;;14057:32:1;;;;14052:2;14037:18;;14030:60;-1:-1:-1;;;14121:3:1;14106:19;14099:35;14018:3;13428:712;-1:-1:-1;;;13428:712:1:o;14398:128::-;14438:3;14469:1;14465:6;14462:1;14459:13;14456:2;;;14475:18;;:::i;:::-;-1:-1:-1;14511:9:1;;14446:80::o;14531:217::-;14571:1;14597;14587:2;;-1:-1:-1;;;14622:31:1;;14676:4;14673:1;14666:15;14704:4;14629:1;14694:15;14587:2;-1:-1:-1;14733:9:1;;14577:171::o;14753:168::-;14793:7;14859:1;14855;14851:6;14847:14;14844:1;14841:21;14836:1;14829:9;14822:17;14818:45;14815:2;;;14866:18;;:::i;:::-;-1:-1:-1;14906:9:1;;14805:116::o;14926:125::-;14966:4;14994:1;14991;14988:8;14985:2;;;14999:18;;:::i;:::-;-1:-1:-1;15036:9:1;;14975:76::o;15056:258::-;15128:1;15138:113;15152:6;15149:1;15146:13;15138:113;;;15228:11;;;15222:18;15209:11;;;15202:39;15174:2;15167:10;15138:113;;;15269:6;15266:1;15263:13;15260:2;;;-1:-1:-1;;15304:1:1;15286:16;;15279:27;15109:205::o;15319:135::-;15358:3;-1:-1:-1;;15379:17:1;;15376:2;;;15399:18;;:::i;:::-;-1:-1:-1;15446:1:1;15435:13;;15366:88::o;15459:127::-;15520:10;15515:3;15511:20;15508:1;15501:31;15551:4;15548:1;15541:15;15575:4;15572:1;15565:15;15591:127;15652:10;15647:3;15643:20;15640:1;15633:31;15683:4;15680:1;15673:15;15707:4;15704:1;15697:15;15723:131;-1:-1:-1;;;;;15798:31:1;;15788:42;;15778:2;;15844:1;15841;15834:12;15859:118;15945:5;15938:13;15931:21;15924:5;15921:32;15911:2;;15967:1;15964;15957:12

ipfs://2c626d23d3b25e9eff278889cead454562f54fc2aa7b9d5cd9434f59ba17bae9