Contract 0x7269bed091977d4A851F106D12CBc60F2423753A

/**
 *Submitted for verification at cronoscan.com on 2022-02-10
*/

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with 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;
    }
}


pragma solidity >=0.6.0 <0.8.0;



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

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

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

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

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

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



pragma solidity >=0.4.0;

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

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

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

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

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

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

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

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

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

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

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

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






pragma solidity >=0.6.2 <0.8.0;

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

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


pragma solidity >=0.4.0;




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

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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





pragma solidity >=0.6.0 <0.8.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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

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

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        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) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

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

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        return a / b;
    }

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

pragma solidity 0.6.12;


// RoganToken with Governance.
contract RoganToken is BEP20 {
    
    // Burn tax rate in basis points. (defaut 2%, max 2%)
    uint16 public burnRateTax = 200;
    
    // Burn address
    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;

    // Max transfer amount rate in basis points. (default is 1% of total supply)
    uint16 public maxTransferAmountRate = 100;
    // Addresses that are excluded from antiWhale
    mapping(address => bool) private _excludedFromAntiWhale;
    // Addresses that are excluded from transfert tax
    mapping(address => bool) private _excludedFromTrsfTax;    
    
    // The operator can only update the transfer burn tax rate & update maxTransferAmountRate & add address to antiWhale and transfer tax whitelist & change operator adresse
    address private _operator;
    // The super operator can only update the owner adresse : This acces is protected by a 15 days timelock : Super operator address can't be change in anyway
    address private _superOperator;

    

    // Events
    event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
    event OwnerTransferred(address indexed previousOwner, address indexed newOwner);
    event BurnRateUpdated(address indexed operator, uint256 previousRate, uint256 newRate);
    event MaxTransferAmountRateUpdated(address indexed operator, uint256 previousRate, uint256 newRate);
    event RoganSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
    event ExcludedFromAntiWhale(address indexed exludedAdresse, bool indexed excludedStatut);
    event ExcludedFromTrsfTax(address indexed exludedAdresse, bool indexed excludedStatut);
    
    // Modifiers
    modifier onlyOperator() {
        require(_operator == msg.sender, "operator: caller is not the operator");
        _;
    }
    
    modifier antiWhale(address sender, address recipient, uint256 amount) {
        if (maxTransferAmount() > 0) {
            if (
                _excludedFromAntiWhale[sender] == false
                && _excludedFromAntiWhale[recipient] == false
            ) {
                require(amount <= maxTransferAmount(), "ROGAN::antiWhale: Transfer amount exceeds the maxTransferAmount");
            }
        }
        _;
    }


    /**
     * @notice Constructs the RoganToken contract.
     */
    constructor() public BEP20("Rogan Token", "ROGAN") {
        _operator = _msgSender();
        emit OperatorTransferred(address(0), _operator);

        _excludedFromAntiWhale[msg.sender] = true;
        _excludedFromAntiWhale[address(0)] = true;
        _excludedFromAntiWhale[address(this)] = true;
        _excludedFromAntiWhale[BURN_ADDRESS] = true;
    }

    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
        _moveDelegates(address(0), _delegates[_to], _amount);
    }

    /// @dev overrides transfer BEP20 function to meet tokenomics of ROGAN
    function _transfer(address sender, address recipient, uint256 amount) internal virtual override antiWhale(sender, recipient, amount) {
        
        if (recipient == BURN_ADDRESS || _excludedFromTrsfTax[sender] == true || _excludedFromTrsfTax[recipient] == true) {            
            super._transfer(sender, recipient, amount);
            _moveDelegates(_delegates[sender], _delegates[recipient], amount);
        } else {
            
            // default burn tax is 2% by default of every transfer
            uint256 burnAmount = amount.mul(burnRateTax).div(10000);

            // default 98% of transfer sent to recipient
            uint256 sendAmount = amount.sub(burnAmount);
            
            require(amount == sendAmount + burnAmount, "ROGAN::transfer: Burn value invalid");

            super._transfer(sender, BURN_ADDRESS, burnAmount);
            _moveDelegates(_delegates[sender], _delegates[BURN_ADDRESS], burnAmount);
            super._transfer(sender, recipient, sendAmount);
            _moveDelegates(_delegates[sender], _delegates[recipient], sendAmount);
            amount = sendAmount;   
        }
    }
    

    /**
     * @dev Returns the max transfer amount.
     */
    function maxTransferAmount() public view returns (uint256) {
        return totalSupply().mul(maxTransferAmountRate).div(10000);
    }

    /**
     * @dev Returns the address is excluded from antiWhale or not.
     */
    function isExcludedFromAntiWhale(address _account) public view returns (bool) {
        return _excludedFromAntiWhale[_account];
    }
    
    /**
     * @dev Returns the address is excluded from transfert tax or not.
     */
    function isExcludedFromTrsfTax(address _account) public view returns (bool) {
        return _excludedFromTrsfTax[_account];
    }    

    /**
     * @dev Update the burn rate.
     * Can only be called by the current operator.
     */
    function updateBurnRate(uint16 _burnRateTax) public onlyOperator {
        require(_burnRateTax <= 200, "ROGAN::updateBurnRate: Burn rate must not exceed the maximum rate.");
        emit BurnRateUpdated(msg.sender, burnRateTax, _burnRateTax);
        burnRateTax = _burnRateTax;
    }

    /**
     * @dev Update the max transfer amount rate.
     * Can only be called by the current operator.
     */
    function updateMaxTransferAmountRate(uint16 _maxTransferAmountRate) public onlyOperator {
        require(_maxTransferAmountRate <= 10000, "ROGAN::updateMaxTransferAmountRate: Max transfer amount rate must not exceed the maximum rate.");
        emit MaxTransferAmountRateUpdated(msg.sender, maxTransferAmountRate, _maxTransferAmountRate);
        maxTransferAmountRate = _maxTransferAmountRate;
    }

    /**
     * @dev Exclude or include an address from antiWhale.
     * Can only be called by the current operator.
     */
    function setExcludedFromAntiWhale(address _account, bool _excluded) public onlyOperator {
        _excludedFromAntiWhale[_account] = _excluded;
        emit ExcludedFromAntiWhale(_account, _excluded);
    }
    
    /**
     * @dev Exclude or include an address from antiWhale.
     * Can only be called by the current operator.
     */
    function setExcludedFromTrsfTax(address _account, bool _excluded) public onlyOperator {
        _excludedFromTrsfTax[_account] = _excluded;
        emit ExcludedFromTrsfTax(_account, _excluded);
    }    

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

    /**
     * @dev Transfers operator of the contract to a new account (`newOperator`).
     * Can only be called by the current operator.
     */
    function transferOperator(address newOperator) public onlyOperator {
        require(newOperator != address(0), "ROGAN::transferOperator: new operator is the zero address");
        emit OperatorTransferred(_operator, newOperator);
        _operator = newOperator;
    }
    
    // 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

    /// @dev 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())),
                getChainId(),
                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), "ROGAN::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "ROGAN::delegateBySig: invalid nonce");
        require(now <= expiry, "ROGAN::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, "ROGAN::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 ROGANs (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.sub(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.add(amount);
                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
            }
        }
    }

    function _writeCheckpoint(
        address delegatee,
        uint32 nCheckpoints,
        uint256 oldVotes,
        uint256 newVotes
    )
        internal
    {
        uint32 blockNumber = safe32(block.number, "ROGAN::_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);
    }

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
    
    //a way to get back other BEP20 tokens sended by error into the ROGAN token contract
    function inCaseTokensGetStuck(address _token, uint256 _amount) public onlyOperator {
        IBEP20(_token).transfer(msg.sender, _amount);
    }    

}

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newRate","type":"uint256"}],"name":"BurnRateUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"exludedAdresse","type":"address"},{"indexed":true,"internalType":"bool","name":"excludedStatut","type":"bool"}],"name":"ExcludedFromAntiWhale","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"exludedAdresse","type":"address"},{"indexed":true,"internalType":"bool","name":"excludedStatut","type":"bool"}],"name":"ExcludedFromTrsfTax","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newRate","type":"uint256"}],"name":"MaxTransferAmountRateUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOperator","type":"address"},{"indexed":true,"internalType":"address","name":"newOperator","type":"address"}],"name":"OperatorTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerTransferred","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":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"router","type":"address"},{"indexed":true,"internalType":"address","name":"pair","type":"address"}],"name":"RoganSwapRouterUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BURN_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DELEGATION_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnRateTax","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint32","name":"","type":"uint32"}],"name":"checkpoints","outputs":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint256","name":"votes","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegator","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getCurrentVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPriorVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"inCaseTokensGetStuck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isExcludedFromAntiWhale","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isExcludedFromTrsfTax","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTransferAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTransferAmountRate","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"bool","name":"_excluded","type":"bool"}],"name":"setExcludedFromAntiWhale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"bool","name":"_excluded","type":"bool"}],"name":"setExcludedFromTrsfTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOperator","type":"address"}],"name":"transferOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_burnRateTax","type":"uint16"}],"name":"updateBurnRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_maxTransferAmountRate","type":"uint16"}],"name":"updateMaxTransferAmountRate","outputs":[],"stateMutability":"nonpayable","type":"function"}]

608060405260c8600660016101000a81548161ffff021916908361ffff1602179055506064600660036101000a81548161ffff021916908361ffff1602179055503480156200004d57600080fd5b506040518060400160405280600b81526020017f526f67616e20546f6b656e0000000000000000000000000000000000000000008152506040518060400160405280600581526020017f524f47414e0000000000000000000000000000000000000000000000000000008152506000620000cc620003ef60201b60201c565b9050806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a350816004908051906020019062000182929190620003f7565b5080600590805190602001906200019b929190620003f7565b506012600660006101000a81548160ff021916908360ff1602179055505050620001ca620003ef60201b60201c565b600960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167f74da04524d50c64947f5dd5381ef1a4dca5cba8ed1d816243f9e48aa0b5617ed60405160405180910390a36001600760003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055506001600760008073ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055506001600760003073ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff02191690831515021790555060016007600061dead73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055506200049d565b600033905090565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f106200043a57805160ff19168380011785556200046b565b828001600101855582156200046b579182015b828111156200046a5782518255916020019190600101906200044d565b5b5090506200047a91906200047e565b5090565b5b80821115620004995760008160009055506001016200047f565b5090565b6145c280620004ad6000396000f3fe608060405234801561001057600080fd5b50600436106102485760003560e01c80637ecebe001161013b578063c6d758cb116100b8578063f1127ed81161007c578063f1127ed814610ca5578063f20bf8d514610d1a578063f2fde38b14610d74578063f607f2b414610db8578063fccc281314610dea57610248565b8063c6d758cb14610b21578063c7f59a6714610b6f578063dd62ed3e14610bbf578063e7a324dc14610c37578063ef45f46714610c5557610248565b8063a457c2d7116100ff578063a457c2d71461096a578063a9059cbb146109ce578063a9e7572314610a32578063b4b5ea5714610a50578063c3cda52014610aa857610248565b80637ecebe00146107e3578063893d20e81461083b5780638da5cb5b1461086f57806395d89b41146108a3578063a0712d681461092657610248565b80633ff8bf2e116101c95780636a141e2c1161018d5780636a141e2c1461068f5780636fcfff45146106c157806370a082311461071f578063715018a614610777578063782d6fe11461078157610248565b80633ff8bf2e1461053957806340c10f191461055b578063570ca735146105a9578063587cde1e146105dd5780635c19a95c1461064b57610248565b806323b872dd1161021057806323b872dd14610392578063269f534c1461041657806329605e7714610470578063313ce567146104b457806339509351146104d557610248565b806306fdde031461024d578063095ea7b3146102d05780630aa80f4b1461033457806318160ddd1461035657806320606b7014610374575b600080fd5b610255610e1e565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561029557808201518184015260208101905061027a565b50505050905090810190601f1680156102c25780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b61031c600480360360408110156102e657600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610ec0565b60405180821515815260200191505060405180910390f35b61033c610ede565b604051808261ffff16815260200191505060405180910390f35b61035e610ef2565b6040518082815260200191505060405180910390f35b61037c610efc565b6040518082815260200191505060405180910390f35b6103fe600480360360608110156103a857600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610f20565b60405180821515815260200191505060405180910390f35b6104586004803603602081101561042c57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610ff9565b60405180821515815260200191505060405180910390f35b6104b26004803603602081101561048657600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061104f565b005b6104bc61123b565b604051808260ff16815260200191505060405180910390f35b610521600480360360408110156104eb57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050611252565b60405180821515815260200191505060405180910390f35b610541611305565b604051808261ffff16815260200191505060405180910390f35b6105a76004803603604081101561057157600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050611319565b005b6105b1611441565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b61061f600480360360208110156105f357600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061146b565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b61068d6004803603602081101561066157600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506114d4565b005b6106bf600480360360208110156106a557600080fd5b81019080803561ffff1690602001909291905050506114e1565b005b610703600480360360208110156106d757600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050611674565b604051808263ffffffff16815260200191505060405180910390f35b6107616004803603602081101561073557600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050611697565b6040518082815260200191505060405180910390f35b61077f6116e0565b005b6107cd6004803603604081101561079757600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291908035906020019092919050505061184d565b6040518082815260200191505060405180910390f35b610825600480360360208110156107f957600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050611c0e565b6040518082815260200191505060405180910390f35b610843611c26565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b610877611c35565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6108ab611c5e565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156108eb5780820151818401526020810190506108d0565b50505050905090810190601f1680156109185780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6109526004803603602081101561093c57600080fd5b8101908080359060200190929190505050611d00565b60405180821515815260200191505060405180910390f35b6109b66004803603604081101561098057600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050611dcb565b60405180821515815260200191505060405180910390f35b610a1a600480360360408110156109e457600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050611e98565b60405180821515815260200191505060405180910390f35b610a3a611eb6565b6040518082815260200191505060405180910390f35b610a9260048036036020811015610a6657600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050611eff565b6040518082815260200191505060405180910390f35b610b1f600480360360c0811015610abe57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291908035906020019092919080359060200190929190803560ff1690602001909291908035906020019092919080359060200190929190505050611fd5565b005b610b6d60048036036040811015610b3757600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050612339565b005b610bbd60048036036040811015610b8557600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803515159060200190929190505050612490565b005b610c2160048036036040811015610bd557600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506125d7565b6040518082815260200191505060405180910390f35b610c3f61265e565b6040518082815260200191505060405180910390f35b610ca360048036036040811015610c6b57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803515159060200190929190505050612682565b005b610cf760048036036040811015610cbb57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803563ffffffff1690602001909291905050506127c9565b604051808363ffffffff1681526020018281526020019250505060405180910390f35b610d5c60048036036020811015610d3057600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061280a565b60405180821515815260200191505060405180910390f35b610db660048036036020811015610d8a57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050612860565b005b610de860048036036020811015610dce57600080fd5b81019080803561ffff169060200190929190505050612a52565b005b610df2612be4565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b606060048054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610eb65780601f10610e8b57610100808354040283529160200191610eb6565b820191906000526020600020905b815481529060010190602001808311610e9957829003601f168201915b5050505050905090565b6000610ed4610ecd612bea565b8484612bf2565b6001905092915050565b600660019054906101000a900461ffff1681565b6000600354905090565b7f8cad95687ba82c2ce50e74f7b754645e5117c3a5bec8151c0726d5857980a86681565b6000610f2d848484612de9565b610fee84610f39612bea565b610fe98560405180606001604052806028815260200161432e60289139600260008b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000610f9f612bea565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546133429092919063ffffffff16565b612bf2565b600190509392505050565b6000600760008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff169050919050565b3373ffffffffffffffffffffffffffffffffffffffff16600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146110f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260248152602001806144396024913960400191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561117b576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260398152602001806143566039913960400191505060405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff16600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f74da04524d50c64947f5dd5381ef1a4dca5cba8ed1d816243f9e48aa0b5617ed60405160405180910390a380600960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6000600660009054906101000a900460ff16905090565b60006112fb61125f612bea565b846112f68560026000611270612bea565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546133fc90919063ffffffff16565b612bf2565b6001905092915050565b600660039054906101000a900461ffff1681565b611321612bea565b73ffffffffffffffffffffffffffffffffffffffff1661133f611c35565b73ffffffffffffffffffffffffffffffffffffffff16146113c8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b6113d28282613484565b61143d6000600b60008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1683613641565b5050565b6000600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6000600b60008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b6114de33826138de565b50565b3373ffffffffffffffffffffffffffffffffffffffff16600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611587576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260248152602001806144396024913960400191505060405180910390fd5b6127108161ffff1611156115e6576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252605e815260200180614483605e913960600191505060405180910390fd5b3373ffffffffffffffffffffffffffffffffffffffff167fb62a50fc861a770636e85357becb3b82a32e911106609d4985871eaf29011e08600660039054906101000a900461ffff1683604051808361ffff1681526020018261ffff1681526020019250505060405180910390a280600660036101000a81548161ffff021916908361ffff16021790555050565b600d6020528060005260406000206000915054906101000a900463ffffffff1681565b6000600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b6116e8612bea565b73ffffffffffffffffffffffffffffffffffffffff16611706611c35565b73ffffffffffffffffffffffffffffffffffffffff161461178f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a360008060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b60004382106118a7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260288152602001806142ae6028913960400191505060405180910390fd5b6000600d60008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900463ffffffff16905060008163ffffffff161415611914576000915050611c08565b82600c60008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006001840363ffffffff1663ffffffff16815260200190815260200160002060000160009054906101000a900463ffffffff1663ffffffff16116119fe57600c60008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006001830363ffffffff1663ffffffff16815260200190815260200160002060010154915050611c08565b82600c60008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008063ffffffff16815260200190815260200160002060000160009054906101000a900463ffffffff1663ffffffff161115611a7f576000915050611c08565b6000806001830390505b8163ffffffff168163ffffffff161115611ba2576000600283830363ffffffff1681611ab157fe5b0482039050611abe6141f7565b600c60008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008363ffffffff1663ffffffff1681526020019081526020016000206040518060400160405290816000820160009054906101000a900463ffffffff1663ffffffff1663ffffffff168152602001600182015481525050905086816000015163ffffffff161415611b7a57806020015195505050505050611c08565b86816000015163ffffffff161015611b9457819350611b9b565b6001820392505b5050611a89565b600c60008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008363ffffffff1663ffffffff1681526020019081526020016000206001015493505050505b92915050565b600e6020528060005260406000206000915090505481565b6000611c30611c35565b905090565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b606060058054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015611cf65780601f10611ccb57610100808354040283529160200191611cf6565b820191906000526020600020905b815481529060010190602001808311611cd957829003601f168201915b5050505050905090565b6000611d0a612bea565b73ffffffffffffffffffffffffffffffffffffffff16611d28611c35565b73ffffffffffffffffffffffffffffffffffffffff1614611db1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b611dc2611dbc612bea565b83613484565b60019050919050565b6000611e8e611dd8612bea565b84611e89856040518060600160405280602581526020016145046025913960026000611e02612bea565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546133429092919063ffffffff16565b612bf2565b6001905092915050565b6000611eac611ea5612bea565b8484612de9565b6001905092915050565b6000611efa612710611eec600660039054906101000a900461ffff1661ffff16611ede610ef2565b613a4f90919063ffffffff16565b613ad590919063ffffffff16565b905090565b600080600d60008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900463ffffffff16905060008163ffffffff1611611f69576000611fcd565b600c60008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006001830363ffffffff1663ffffffff168152602001908152602001600020600101545b915050919050565b60007f8cad95687ba82c2ce50e74f7b754645e5117c3a5bec8151c0726d5857980a866612000610e1e565b8051906020012061200f613b5e565b30604051602001808581526020018481526020018381526020018273ffffffffffffffffffffffffffffffffffffffff16815260200194505050505060405160208183030381529060405280519060200120905060007fe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf888888604051602001808581526020018473ffffffffffffffffffffffffffffffffffffffff1681526020018381526020018281526020019450505050506040516020818303038152906040528051906020012090506000828260405160200180807f190100000000000000000000000000000000000000000000000000000000000081525060020183815260200182815260200192505050604051602081830303815290604052805190602001209050600060018288888860405160008152602001604052604051808581526020018460ff1681526020018381526020018281526020019450505050506020604051602081039080840390855afa158015612193573d6000803e3d6000fd5b505050602060405103519050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415612225576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602781526020018061423d6027913960400191505060405180910390fd5b600e60008273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008154809291906001019190505589146122ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260238152602001806142d66023913960400191505060405180910390fd5b87421115612323576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260278152602001806143f16027913960400191505060405180910390fd5b61232d818b6138de565b50505050505050505050565b3373ffffffffffffffffffffffffffffffffffffffff16600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146123df576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260248152602001806144396024913960400191505060405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff1663a9059cbb33836040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050602060405180830381600087803b15801561245057600080fd5b505af1158015612464573d6000803e3d6000fd5b505050506040513d602081101561247a57600080fd5b8101908080519060200190929190505050505050565b3373ffffffffffffffffffffffffffffffffffffffff16600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614612536576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260248152602001806144396024913960400191505060405180910390fd5b80600760008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055508015158273ffffffffffffffffffffffffffffffffffffffff167f46e542c7dcc512f9d4c5ef6470efcb6729025d935367e1c2c8dc49d8e35eaa8860405160405180910390a35050565b6000600260008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b7fe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf81565b3373ffffffffffffffffffffffffffffffffffffffff16600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614612728576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260248152602001806144396024913960400191505060405180910390fd5b80600860008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055508015158273ffffffffffffffffffffffffffffffffffffffff167fb259f09d4d7208218d0e01f99c2deab3ef8e25b79347d579b899a4a346064a4d60405160405180910390a35050565b600c602052816000526040600020602052806000526040600020600091509150508060000160009054906101000a900463ffffffff16908060010154905082565b6000600860008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff169050919050565b612868612bea565b73ffffffffffffffffffffffffffffffffffffffff16612886611c35565b73ffffffffffffffffffffffffffffffffffffffff161461290f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415612995576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260268152602001806142886026913960400191505060405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a3806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b3373ffffffffffffffffffffffffffffffffffffffff16600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614612af8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260248152602001806144396024913960400191505060405180910390fd5b60c88161ffff161115612b56576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260428152602001806145296042913960600191505060405180910390fd5b3373ffffffffffffffffffffffffffffffffffffffff167f3eec69630b6f49d4e10eec296fce4baddec5f34c5430fb2cd72f8c4218f63fd0600660019054906101000a900461ffff1683604051808361ffff1681526020018261ffff1681526020019250505060405180910390a280600660016101000a81548161ffff021916908361ffff16021790555050565b61dead81565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415612c78576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260248152602001806142646024913960400191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415612cfe576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602281526020018061456b6022913960400191505060405180910390fd5b80600260008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925836040518082815260200191505060405180910390a3505050565b8282826000612df6611eb6565b1115612f135760001515600760008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff161515148015612eac575060001515600760008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff161515145b15612f1257612eb9611eb6565b811115612f11576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252603f8152602001806143b2603f913960400191505060405180910390fd5b5b5b61dead73ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff161480612f9f575060011515600860008873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff161515145b80612ffa575060011515600860008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff161515145b156130d85761300a868686613b6b565b6130d3600b60008873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16600b60008873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1686613641565b61333a565b6000613115612710613107600660019054906101000a900461ffff1661ffff1688613a4f90919063ffffffff16565b613ad590919063ffffffff16565b9050600061312c8287613e2590919063ffffffff16565b90508181018614613188576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602381526020018061438f6023913960400191505060405180910390fd5b6131958861dead84613b6b565b613260600b60008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16600b600061dead73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1684613641565b61326b888883613b6b565b613334600b60008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16600b60008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1683613641565b80955050505b505050505050565b60008383111582906133ef576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825283818151815260200191508051906020019080838360005b838110156133b4578082015181840152602081019050613399565b50505050905090810190601f1680156133e15780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b5082840390509392505050565b60008082840190508381101561347a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601b8152602001807f536166654d6174683a206164646974696f6e206f766572666c6f77000000000081525060200191505060405180910390fd5b8091505092915050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415613527576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601f8152602001807f42455032303a206d696e7420746f20746865207a65726f20616464726573730081525060200191505060405180910390fd5b61353c816003546133fc90919063ffffffff16565b60038190555061359481600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546133fc90919063ffffffff16565b600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040518082815260200191505060405180910390a35050565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415801561367d5750600081115b156138d957600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16146137ad576000600d60008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900463ffffffff1690506000808263ffffffff1611613720576000613784565b600c60008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006001840363ffffffff1663ffffffff168152602001908152602001600020600101545b9050600061379b8483613e2590919063ffffffff16565b90506137a986848484613ea8565b5050505b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16146138d8576000600d60008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900463ffffffff1690506000808263ffffffff161161384b5760006138af565b600c60008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006001840363ffffffff1663ffffffff168152602001908152602001600020600101545b905060006138c684836133fc90919063ffffffff16565b90506138d485848484613ea8565b5050505b5b505050565b6000600b60008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050600061394d84611697565b905082600b60008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508273ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167f3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f60405160405180910390a4613a49828483613641565b50505050565b600080831415613a625760009050613acf565b6000828402905082848281613a7357fe5b0414613aca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260218152602001806144186021913960400191505060405180910390fd5b809150505b92915050565b6000808211613b4c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601a8152602001807f536166654d6174683a206469766973696f6e206279207a65726f00000000000081525060200191505060405180910390fd5b818381613b5557fe5b04905092915050565b6000804690508091505090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415613bf1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260258152602001806142186025913960400191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415613c77576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260238152602001806144e16023913960400191505060405180910390fd5b613ce38160405180606001604052806026815260200161445d60269139600160008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546133429092919063ffffffff16565b600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550613d7881600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546133fc90919063ffffffff16565b600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040518082815260200191505060405180910390a3505050565b600082821115613e9d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601e8152602001807f536166654d6174683a207375627472616374696f6e206f766572666c6f77000081525060200191505060405180910390fd5b818303905092915050565b6000613ecc436040518060600160405280603581526020016142f96035913961413c565b905060008463ffffffff16118015613f6157508063ffffffff16600c60008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006001870363ffffffff1663ffffffff16815260200190815260200160002060000160009054906101000a900463ffffffff1663ffffffff16145b15613fd25781600c60008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006001870363ffffffff1663ffffffff168152602001908152602001600020600101819055506140df565b60405180604001604052808263ffffffff16815260200183815250600c60008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008663ffffffff1663ffffffff16815260200190815260200160002060008201518160000160006101000a81548163ffffffff021916908363ffffffff1602179055506020820151816001015590505060018401600d60008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548163ffffffff021916908363ffffffff1602179055505b8473ffffffffffffffffffffffffffffffffffffffff167fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a7248484604051808381526020018281526020019250505060405180910390a25050505050565b6000640100000000831082906141ed576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825283818151815260200191508051906020019080838360005b838110156141b2578082015181840152602081019050614197565b50505050905090810190601f1680156141df5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b5082905092915050565b6040518060400160405280600063ffffffff16815260200160008152509056fe42455032303a207472616e736665722066726f6d20746865207a65726f2061646472657373524f47414e3a3a64656c656761746542795369673a20696e76616c6964207369676e617475726542455032303a20617070726f76652066726f6d20746865207a65726f20616464726573734f776e61626c653a206e6577206f776e657220697320746865207a65726f2061646472657373524f47414e3a3a6765745072696f72566f7465733a206e6f74207965742064657465726d696e6564524f47414e3a3a64656c656761746542795369673a20696e76616c6964206e6f6e6365524f47414e3a3a5f7772697465436865636b706f696e743a20626c6f636b206e756d6265722065786365656473203332206269747342455032303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e6365524f47414e3a3a7472616e736665724f70657261746f723a206e6577206f70657261746f7220697320746865207a65726f2061646472657373524f47414e3a3a7472616e736665723a204275726e2076616c756520696e76616c6964524f47414e3a3a616e74695768616c653a205472616e7366657220616d6f756e74206578636565647320746865206d61785472616e73666572416d6f756e74524f47414e3a3a64656c656761746542795369673a207369676e61747572652065787069726564536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f776f70657261746f723a2063616c6c6572206973206e6f7420746865206f70657261746f7242455032303a207472616e7366657220616d6f756e7420657863656564732062616c616e6365524f47414e3a3a7570646174654d61785472616e73666572416d6f756e74526174653a204d6178207472616e7366657220616d6f756e742072617465206d757374206e6f742065786365656420746865206d6178696d756d20726174652e42455032303a207472616e7366657220746f20746865207a65726f206164647265737342455032303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726f524f47414e3a3a7570646174654275726e526174653a204275726e2072617465206d757374206e6f742065786365656420746865206d6178696d756d20726174652e42455032303a20617070726f766520746f20746865207a65726f2061646472657373a2646970667358221220f6517922e1cfc1e4ba25ec7f5052b89b858c8f4470a42924819fe67bf2e81c3d64736f6c634300060c0033

32014:16065:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16685:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18172:161;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;32115:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;17161:100;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40241:122;;;:::i;:::-;;;;;;;;;;;;;;;;;;;18804:397;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;36616:136;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;38948:274;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;16844:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;19609:210;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;32352:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;34893:162;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;38703:85;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;41224:149;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;41517:104;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;37520:405;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;40119:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;17323:119;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;2676:148;;;:::i;:::-;;44123:1254;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40655:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;16528:94;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;2025:87;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;17001:96;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20850:130;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;20321:311;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;17654:167;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;36386:136;;;:::i;:::-;;;;;;;;;;;;;;;;;;;43437:255;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;42055:1181;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;47924:146;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;38062:209;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;17883:143;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40457:117;;;:::i;:::-;;;;;;;;;;;;;;;;;;;38412:203;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;39980:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;36854:132;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;2979:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;37103:289;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;32180:81;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;16685:92;16731:13;16764:5;16757:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16685:92;:::o;18172:161::-;18247:4;18264:39;18273:12;:10;:12::i;:::-;18287:7;18296:6;18264:8;:39::i;:::-;18321:4;18314:11;;18172:161;;;;:::o;32115:31::-;;;;;;;;;;;;;:::o;17161:100::-;17214:7;17241:12;;17234:19;;17161:100;:::o;40241:122::-;40283:80;40241:122;:::o;18804:397::-;18936:4;18953:36;18963:6;18971:9;18982:6;18953:9;:36::i;:::-;19000:171;19023:6;19044:12;:10;:12::i;:::-;19071:89;19109:6;19071:89;;;;;;;;;;;;;;;;;:11;:19;19083:6;19071:19;;;;;;;;;;;;;;;:33;19091:12;:10;:12::i;:::-;19071:33;;;;;;;;;;;;;;;;:37;;:89;;;;;:::i;:::-;19000:8;:171::i;:::-;19189:4;19182:11;;18804:397;;;;;:::o;36616:136::-;36688:4;36712:22;:32;36735:8;36712:32;;;;;;;;;;;;;;;;;;;;;;;;;36705:39;;36616:136;;;:::o;38948:274::-;33822:10;33809:23;;:9;;;;;;;;;;;:23;;;33801:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39057:1:::1;39034:25;;:11;:25;;;;39026:95;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39168:11;39137:43;;39157:9;;;;;;;;;;;39137:43;;;;;;;;;;;;39203:11;39191:9;;:23;;;;;;;;;;;;;;;;;;38948:274:::0;:::o;16844:92::-;16894:5;16919:9;;;;;;;;;;;16912:16;;16844:92;:::o;19609:210::-;19689:4;19706:83;19715:12;:10;:12::i;:::-;19729:7;19738:50;19777:10;19738:11;:25;19750:12;:10;:12::i;:::-;19738:25;;;;;;;;;;;;;;;:34;19764:7;19738:34;;;;;;;;;;;;;;;;:38;;:50;;;;:::i;:::-;19706:8;:83::i;:::-;19807:4;19800:11;;19609:210;;;;:::o;32352:41::-;;;;;;;;;;;;;:::o;34893:162::-;2256:12;:10;:12::i;:::-;2245:23;;:7;:5;:7::i;:::-;:23;;;2237:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34965:19:::1;34971:3;34976:7;34965:5;:19::i;:::-;34995:52;35018:1;35022:10;:15;35033:3;35022:15;;;;;;;;;;;;;;;;;;;;;;;;;35039:7;34995:14;:52::i;:::-;34893:162:::0;;:::o;38703:85::-;38744:7;38771:9;;;;;;;;;;;38764:16;;38703:85;:::o;41224:149::-;41312:7;41344:10;:21;41355:9;41344:21;;;;;;;;;;;;;;;;;;;;;;;;;41337:28;;41224:149;;;:::o;41517:104::-;41581:32;41591:10;41603:9;41581;:32::i;:::-;41517:104;:::o;37520:405::-;33822:10;33809:23;;:9;;;;;;;;;;;:23;;;33801:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37653:5:::1;37627:22;:31;;;;37619:138;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37802:10;37773:87;;;37814:21;;;;;;;;;;;37837:22;37773:87;;;;;;;;;;;;;;;;;;;;;;;;;;;;37895:22;37871:21;;:46;;;;;;;;;;;;;;;;;;37520:405:::0;:::o;40119:49::-;;;;;;;;;;;;;;;;;;;;;;:::o;17323:119::-;17389:7;17416:9;:18;17426:7;17416:18;;;;;;;;;;;;;;;;17409:25;;17323:119;;;:::o;2676:148::-;2256:12;:10;:12::i;:::-;2245:23;;:7;:5;:7::i;:::-;:23;;;2237:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2783:1:::1;2746:40;;2767:6;::::0;::::1;;;;;;;;2746:40;;;;;;;;;;;;2814:1;2797:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;2676:148::o:0;44123:1254::-;44231:7;44278:12;44264:11;:26;44256:79;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44348:19;44370:14;:23;44385:7;44370:23;;;;;;;;;;;;;;;;;;;;;;;;;44348:45;;44424:1;44408:12;:17;;;44404:58;;;44449:1;44442:8;;;;;44404:58;44574:11;44522;:20;44534:7;44522:20;;;;;;;;;;;;;;;:38;44558:1;44543:12;:16;44522:38;;;;;;;;;;;;;;;:48;;;;;;;;;;;;:63;;;44518:147;;44609:11;:20;44621:7;44609:20;;;;;;;;;;;;;;;:38;44645:1;44630:12;:16;44609:38;;;;;;;;;;;;;;;:44;;;44602:51;;;;;44518:147;44762:11;44726;:20;44738:7;44726:20;;;;;;;;;;;;;;;:23;44747:1;44726:23;;;;;;;;;;;;;:33;;;;;;;;;;;;:47;;;44722:88;;;44797:1;44790:8;;;;;44722:88;44822:12;44849;44879:1;44864:12;:16;44849:31;;44891:428;44906:5;44898:13;;:5;:13;;;44891:428;;;44928:13;44970:1;44961:5;44953;:13;44952:19;;;;;;;;44944:5;:27;44928:43;;45013:20;;:::i;:::-;45036:11;:20;45048:7;45036:20;;;;;;;;;;;;;;;:28;45057:6;45036:28;;;;;;;;;;;;;;;45013:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45099:11;45083:2;:12;;;:27;;;45079:229;;;45138:2;:8;;;45131:15;;;;;;;;;45079:229;45187:11;45172:2;:12;;;:26;;;45168:140;;;45227:6;45219:14;;45168:140;;;45291:1;45282:6;:10;45274:18;;45168:140;44891:428;;;;;45336:11;:20;45348:7;45336:20;;;;;;;;;;;;;;;:27;45357:5;45336:27;;;;;;;;;;;;;;;:33;;;45329:40;;;;;44123:1254;;;;;:::o;40655:39::-;;;;;;;;;;;;;;;;;:::o;16528:94::-;16580:7;16607;:5;:7::i;:::-;16600:14;;16528:94;:::o;2025:87::-;2071:7;2098:6;;;;;;;;;;;2091:13;;2025:87;:::o;17001:96::-;17049:13;17082:7;17075:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17001:96;:::o;20850:130::-;20906:4;2256:12;:10;:12::i;:::-;2245:23;;:7;:5;:7::i;:::-;:23;;;2237:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20923:27:::1;20929:12;:10;:12::i;:::-;20943:6;20923:5;:27::i;:::-;20968:4;20961:11;;20850:130:::0;;;:::o;20321:311::-;20406:4;20423:179;20446:12;:10;:12::i;:::-;20473:7;20495:96;20534:15;20495:96;;;;;;;;;;;;;;;;;:11;:25;20507:12;:10;:12::i;:::-;20495:25;;;;;;;;;;;;;;;:34;20521:7;20495:34;;;;;;;;;;;;;;;;:38;;:96;;;;;:::i;:::-;20423:8;:179::i;:::-;20620:4;20613:11;;20321:311;;;;:::o;17654:167::-;17732:4;17749:42;17759:12;:10;:12::i;:::-;17773:9;17784:6;17749:9;:42::i;:::-;17809:4;17802:11;;17654:167;;;;:::o;36386:136::-;36436:7;36463:51;36508:5;36463:40;36481:21;;;;;;;;;;;36463:40;;:13;:11;:13::i;:::-;:17;;:40;;;;:::i;:::-;:44;;:51;;;;:::i;:::-;36456:58;;36386:136;:::o;43437:255::-;43529:7;43554:19;43576:14;:23;43591:7;43576:23;;;;;;;;;;;;;;;;;;;;;;;;;43554:45;;43632:1;43617:12;:16;;;:67;;43683:1;43617:67;;;43636:11;:20;43648:7;43636:20;;;;;;;;;;;;;;;:38;43672:1;43657:12;:16;43636:38;;;;;;;;;;;;;;;:44;;;43617:67;43610:74;;;43437:255;;;:::o;42055:1181::-;42248:23;40283:80;42377:6;:4;:6::i;:::-;42361:24;;;;;;42404:12;:10;:12::i;:::-;42443:4;42298:165;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42274:200;;;;;;42248:226;;42487:18;40503:71;42599:9;42627:5;42651:6;42532:140;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42508:175;;;;;;42487:196;;42696:14;42801:15;42835:10;42737:123;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42713:158;;;;;;42696:175;;42884:17;42904:26;42914:6;42922:1;42925;42928;42904:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42884:46;;42970:1;42949:23;;:9;:23;;;;42941:75;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43044:6;:17;43051:9;43044:17;;;;;;;;;;;;;;;;:19;;;;;;;;;;;;43035:5;:28;43027:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43129:6;43122:3;:13;;43114:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43197:31;43207:9;43218;43197;:31::i;:::-;43190:38;;;;42055:1181;;;;;;:::o;47924:146::-;33822:10;33809:23;;:9;;;;;;;;;;;:23;;;33801:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48025:6:::1;48018:23;;;48042:10;48054:7;48018:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;47924:146:::0;;:::o;38062:209::-;33822:10;33809:23;;:9;;;;;;;;;;;:23;;;33801:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38196:9:::1;38161:22;:32;38184:8;38161:32;;;;;;;;;;;;;;;;:44;;;;;;;;;;;;;;;;;;38253:9;38221:42;;38243:8;38221:42;;;;;;;;;;;;38062:209:::0;;:::o;17883:143::-;17964:7;17991:11;:18;18003:5;17991:18;;;;;;;;;;;;;;;:27;18010:7;17991:27;;;;;;;;;;;;;;;;17984:34;;17883:143;;;;:::o;40457:117::-;40503:71;40457:117;:::o;38412:203::-;33822:10;33809:23;;:9;;;;;;;;;;;:23;;;33801:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38542:9:::1;38509:20;:30;38530:8;38509:30;;;;;;;;;;;;;;;;:42;;;;;;;;;;;;;;;;;;38597:9;38567:40;;38587:8;38567:40;;;;;;;;;;;;38412:203:::0;;:::o;39980:70::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;36854:132::-;36924:4;36948:20;:30;36969:8;36948:30;;;;;;;;;;;;;;;;;;;;;;;;;36941:37;;36854:132;;;:::o;2979:244::-;2256:12;:10;:12::i;:::-;2245:23;;:7;:5;:7::i;:::-;:23;;;2237:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3088:1:::1;3068:22;;:8;:22;;;;3060:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3178:8;3149:38;;3170:6;::::0;::::1;;;;;;;;3149:38;;;;;;;;;;;;3207:8;3198:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;2979:244:::0;:::o;37103:289::-;33822:10;33809:23;;:9;;;;;;;;;;;:23;;;33801:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37203:3:::1;37187:12;:19;;;;37179:98;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37309:10;37293:54;;;37321:11;;;;;;;;;;;37334:12;37293:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;37372:12;37358:11;;:26;;;;;;;;;;;;;;;;;;37103:289:::0;:::o;32180:81::-;32219:42;32180:81;:::o;613:106::-;666:15;701:10;694:17;;613:106;:::o;23692:372::-;23837:1;23820:19;;:5;:19;;;;23812:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23918:1;23899:21;;:7;:21;;;;23891:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24002:6;23972:11;:18;23984:5;23972:18;;;;;;;;;;;;;;;:27;23991:7;23972:27;;;;;;;;;;;;;;;:36;;;;24040:7;24024:32;;24033:5;24024:32;;;24049:6;24024:32;;;;;;;;;;;;;;;;;;23692:372;;;:::o;35139:1169::-;35245:6;35253:9;35264:6;34012:1;33990:19;:17;:19::i;:::-;:23;33986:335;;;34086:5;34052:39;;:22;:30;34075:6;34052:30;;;;;;;;;;;;;;;;;;;;;;;;;:39;;;:102;;;;;34149:5;34112:42;;:22;:33;34135:9;34112:33;;;;;;;;;;;;;;;;;;;;;;;;;:42;;;34052:102;34030:280;;;34207:19;:17;:19::i;:::-;34197:6;:29;;34189:105;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34030:280;33986:335;32219:42:::1;35297:25;;:9;:25;;;:65;;;;35358:4;35326:36;;:20;:28;35347:6;35326:28;;;;;;;;;;;;;;;;;;;;;;;;;:36;;;35297:65;:108;;;;35401:4;35366:39;;:20;:31;35387:9;35366:31;;;;;;;;;;;;;;;;;;;;;;;;;:39;;;35297:108;35293:1008;;;35434:42;35450:6;35458:9;35469:6;35434:15;:42::i;:::-;35491:65;35506:10;:18;35517:6;35506:18;;;;;;;;;;;;;;;;;;;;;;;;;35526:10;:21;35537:9;35526:21;;;;;;;;;;;;;;;;;;;;;;;;;35549:6;35491:14;:65::i;:::-;35293:1008;;;35671:18;35692:34;35720:5;35692:23;35703:11;;;;;;;;;;;35692:23;;:6;:10;;:23;;;;:::i;:::-;:27;;:34;;;;:::i;:::-;35671:55;;35801:18;35822:22;35833:10;35822:6;:10;;:22;;;;:::i;:::-;35801:43;;35904:10;35891;:23;35881:6;:33;35873:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35971:49;35987:6;32219:42;36009:10;35971:15;:49::i;:::-;36035:72;36050:10;:18;36061:6;36050:18;;;;;;;;;;;;;;;;;;;;;;;;;36070:10;:24;32219:42;36070:24;;;;;;;;;;;;;;;;;;;;;;;;;36096:10;36035:14;:72::i;:::-;36122:46;36138:6;36146:9;36157:10;36122:15;:46::i;:::-;36183:69;36198:10;:18;36209:6;36198:18;;;;;;;;;;;;;;;;;;;;;;;;;36218:10;:21;36229:9;36218:21;;;;;;;;;;;;;;;;;;;;;;;;;36241:10;36183:14;:69::i;:::-;36276:10;36267:19;;35293:1008;;;35139:1169:::0;;;;;;:::o;30113:166::-;30199:7;30232:1;30227;:6;;30235:12;30219:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30270:1;30266;:5;30259:12;;30113:166;;;;;:::o;27286:179::-;27344:7;27364:9;27380:1;27376;:5;27364:17;;27405:1;27400;:6;;27392:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27456:1;27449:8;;;27286:179;;;;:::o;22264:308::-;22359:1;22340:21;;:7;:21;;;;22332:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22425:24;22442:6;22425:12;;:16;;:24;;;;:::i;:::-;22410:12;:39;;;;22481:30;22504:6;22481:9;:18;22491:7;22481:18;;;;;;;;;;;;;;;;:22;;:30;;;;:::i;:::-;22460:9;:18;22470:7;22460:18;;;;;;;;;;;;;;;:51;;;;22548:7;22527:37;;22544:1;22527:37;;;22557:6;22527:37;;;;;;;;;;;;;;;;;;22264:308;;:::o;45832:947::-;45938:6;45928:16;;:6;:16;;;;:30;;;;;45957:1;45948:6;:10;45928:30;45924:848;;;45997:1;45979:20;;:6;:20;;;45975:385;;46068:16;46087:14;:22;46102:6;46087:22;;;;;;;;;;;;;;;;;;;;;;;;;46068:41;;46128:17;46160:1;46148:9;:13;;;:60;;46207:1;46148:60;;;46164:11;:19;46176:6;46164:19;;;;;;;;;;;;;;;:34;46196:1;46184:9;:13;46164:34;;;;;;;;;;;;;;;:40;;;46148:60;46128:80;;46227:17;46247:21;46261:6;46247:9;:13;;:21;;;;:::i;:::-;46227:41;;46287:57;46304:6;46312:9;46323;46334;46287:16;:57::i;:::-;45975:385;;;;46398:1;46380:20;;:6;:20;;;46376:385;;46469:16;46488:14;:22;46503:6;46488:22;;;;;;;;;;;;;;;;;;;;;;;;;46469:41;;46529:17;46561:1;46549:9;:13;;;:60;;46608:1;46549:60;;;46565:11;:19;46577:6;46565:19;;;;;;;;;;;;;;;:34;46597:1;46585:9;:13;46565:34;;;;;;;;;;;;;;;:40;;;46549:60;46529:80;;46628:17;46648:21;46662:6;46648:9;:13;;:21;;;;:::i;:::-;46628:41;;46688:57;46705:6;46713:9;46724;46735;46688:16;:57::i;:::-;46376:385;;;;45924:848;45832:947;;;:::o;45385:439::-;45476:23;45502:10;:21;45513:9;45502:21;;;;;;;;;;;;;;;;;;;;;;;;;45476:47;;45534:24;45561:20;45571:9;45561;:20::i;:::-;45534:47;;45662:9;45638:10;:21;45649:9;45638:21;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;45733:9;45689:54;;45716:15;45689:54;;45705:9;45689:54;;;;;;;;;;;;45756:60;45771:15;45788:9;45799:16;45756:14;:60::i;:::-;45385:439;;;;:::o;28165:220::-;28223:7;28252:1;28247;:6;28243:20;;;28262:1;28255:8;;;;28243:20;28274:9;28290:1;28286;:5;28274:17;;28319:1;28314;28310;:5;;;;;;:10;28302:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28376:1;28369:8;;;28165:220;;;;;:::o;28863:153::-;28921:7;28953:1;28949;:5;28941:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29007:1;29003;:5;;;;;;28996:12;;28863:153;;;;:::o;47669:::-;47714:4;47731:15;47779:9;47768:20;;47807:7;47800:14;;;47669:153;:::o;21470:513::-;21628:1;21610:20;;:6;:20;;;;21602:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21712:1;21691:23;;:9;:23;;;;21683:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21787;21809:6;21787:71;;;;;;;;;;;;;;;;;:9;:17;21797:6;21787:17;;;;;;;;;;;;;;;;:21;;:71;;;;;:::i;:::-;21767:9;:17;21777:6;21767:17;;;;;;;;;;;;;;;:91;;;;21892:32;21917:6;21892:9;:20;21902:9;21892:20;;;;;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;21869:9;:20;21879:9;21869:20;;;;;;;;;;;;;;;:55;;;;21957:9;21940:35;;21949:6;21940:35;;;21968:6;21940:35;;;;;;;;;;;;;;;;;;21470:513;;;:::o;27748:158::-;27806:7;27839:1;27834;:6;;27826:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27897:1;27893;:5;27886:12;;27748:158;;;;:::o;46787:705::-;46966:18;46987:77;46994:12;46987:77;;;;;;;;;;;;;;;;;:6;:77::i;:::-;46966:98;;47096:1;47081:12;:16;;;:85;;;;;47155:11;47101:65;;:11;:22;47113:9;47101:22;;;;;;;;;;;;;;;:40;47139:1;47124:12;:16;47101:40;;;;;;;;;;;;;;;:50;;;;;;;;;;;;:65;;;47081:85;47077:339;;;47232:8;47183:11;:22;47195:9;47183:22;;;;;;;;;;;;;;;:40;47221:1;47206:12;:16;47183:40;;;;;;;;;;;;;;;:46;;:57;;;;47077:339;;;47312:33;;;;;;;;47323:11;47312:33;;;;;;47336:8;47312:33;;;47273:11;:22;47285:9;47273:22;;;;;;;;;;;;;;;:36;47296:12;47273:36;;;;;;;;;;;;;;;:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47403:1;47388:12;:16;47360:14;:25;47375:9;47360:25;;;;;;;;;;;;;;;;:44;;;;;;;;;;;;;;;;;;47077:339;47454:9;47433:51;;;47465:8;47475;47433:51;;;;;;;;;;;;;;;;;;;;;;;;46787:705;;;;;:::o;47500:161::-;47575:6;47606:5;47602:1;:9;47613:12;47594:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47651:1;47637:16;;47500:161;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;:::o

ipfs://f6517922e1cfc1e4ba25ec7f5052b89b858c8f4470a42924819fe67bf2e81c3d