Token StrangerCoin

Overview CRC20

Price
$0.00 @ 0.000000 CRO
Fully Diluted Market Cap
Total Supply:
6,000,000,000 Stranger

Holders:
111 addresses

Transfers:
-

Contract:
0x9C68B047d93dA634014776851Bd4aE24c86931090x9C68B047d93dA634014776851Bd4aE24c8693109

Decimals:
9

Social Profiles:
Not Available, Update ?

Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
Loading

Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume

Contract Source Code Verified (Exact Match)

Contract Name:
StrangerCoin

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-04-07
*/

/*
* 
Stranger

Initial Supply: 6 000 000 000 tokens
Max Wallet: 1%

Tax: 
10% buy
15% sell

https://t.me/strangercoin
https://strangercoin.com
*
*/

pragma solidity ^0.8.4;

// SPDX-License-Identifier: UNLICENSED

interface IBEP20 {
  function totalSupply() external view returns (uint256);
  function decimals() external view returns (uint8);
  function symbol() external view returns (string memory);
  function name() external view returns (string memory);
  function getOwner() external view returns (address);
  function balanceOf(address account) external view returns (uint256);
  function transfer(address recipient, uint256 amount) external returns (bool);
  function allowance(address _owner, address spender) external view returns (uint256);
  function approve(address spender, uint256 amount) external returns (bool);
  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}


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

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);
    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);
    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}

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

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);
    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);
    function createPair(address tokenA, address tokenB) external returns (address pair);
    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

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

    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getamountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getamountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getamountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getamountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

interface IPancakeRouter02 is IPancakeRouter01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}



/**
 * @dev 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 {
    address private _owner;

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

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

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

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

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

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

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

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

    struct Set {
        // Storage of set values
        bytes32[] _values;

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

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

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

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

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

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

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

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

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

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

//Stranger Coin Contract /////////////

contract StrangerCoin is IBEP20, Ownable
{
    using Address for address;
    using EnumerableSet for EnumerableSet.AddressSet;
    
    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowances;
    mapping (address => uint256) private _sellLock;
    mapping (address => uint256) private _buyLock;

    EnumerableSet.AddressSet private _excluded;
    EnumerableSet.AddressSet private _excludedFromSellLock;
    EnumerableSet.AddressSet private _excludedFromBuyLock;
    EnumerableSet.AddressSet private _excludedFromStaking;
    //Token Info
    string private constant _name = 'StrangerCoin';
    string private constant _symbol = 'Stranger';
    uint8 private constant _decimals = 9;
    uint256 public constant InitialSupply= 6000000000 * 10**_decimals;//equals 500B tokens

    //Divider for the MaxBalance based on circulating Supply (1%)
    uint8 public constant BalanceLimitDivider=100;
    //Divider for sellLimit based on circulating Supply (1%))
    uint16 public constant SellLimitDivider=100;
    //Sellers get locked for MaxSellLockTime (put in seconds, works better especially if changing later) so they can't dump repeatedly
    uint16 public constant MaxSellLockTime= 0 seconds;
	//Buyers get locked for MaxBuyLockTime (put in seconds, works better especially if changing later) so they can't buy repeatedly
    uint16 public constant MaxBuyLockTime= 0 seconds;
    //The time Liquidity gets locked at start and prolonged once it gets released
    uint256 private constant DefaultLiquidityLockTime= 1800;
    //DevWallets
    address public TeamWallet=payable(0xFDf30eBEBCC359E1B807C540749446fc68B455a7);
    address public walletTwo=payable(0xA8EAC83478d6ad8e3ae0f7eBD7D4C71B6b52866C);
    //TestNet
    //address private constant PancakeRouter=0x9Ac64Cc6e4415144C455BD8E4837Fea55603e5c3;
    //MainNet
    address private constant PancakeRouter=0x145677FC4d9b8F19B5D56d1820c48e0443049a30;

    //variables that track balanceLimit and sellLimit,
    //can be updated based on circulating supply and Sell- and BalanceLimitDividers
    uint256 private _circulatingSupply =InitialSupply;
    uint256 public  balanceLimit = _circulatingSupply;
    uint256 public  sellLimit = _circulatingSupply;
	uint256 private antiWhale = 600000000 * 10**_decimals;
    
    //Tracks the current Taxes, different Taxes can be applied for buy/sell/transfer
    uint8 private _buyTax;
    uint8 private _sellTax;
    uint8 private _transferTax;

    uint8 private _burnTax;
    uint8 private _liquidityTax;
    uint8 private _stakingTax;

       
    address private _pancakePairAddress; 
    IPancakeRouter02 private  _pancakeRouter;
    
    //Checks if address is in Team, is needed to give Team access even if contract is renounced
    //Team doesn't have access to critical Functions that could turn this into a Rugpull(Exept liquidity unlocks)
    function _isTeam(address addr) private view returns (bool){
        return addr==owner()||addr==TeamWallet||addr==walletTwo;
    }

    //Constructor///////////

    constructor () {
        //contract creator gets 90% of the token to create LP-Pair
        uint256 deployerBalance=_circulatingSupply;
        _balances[msg.sender] = deployerBalance;
        emit Transfer(address(0), msg.sender, deployerBalance);
        // Pancake Router
        _pancakeRouter = IPancakeRouter02(PancakeRouter);
        //Creates a Pancake Pair
        _pancakePairAddress = IPancakeFactory(_pancakeRouter.factory()).createPair(address(this), _pancakeRouter.WETH());
        
        //Sets Buy/Sell limits
        balanceLimit=InitialSupply/BalanceLimitDivider;
        sellLimit=InitialSupply/SellLimitDivider;

		//Sets sellLockTime
        sellLockTime=0;
		
		//Sets buyLockTime
        buyLockTime=0;

        //Set Starting Tax 
        
        _buyTax=10;
        _sellTax=15;
        _transferTax=0;

        _burnTax=0;
        _liquidityTax=8;
        _stakingTax=92;

        //Team wallets and deployer are excluded from Taxes
        _excluded.add(TeamWallet);
        _excluded.add(walletTwo);
        _excluded.add(msg.sender);
        //excludes Pancake Router, pair, contract and burn address from staking
        _excludedFromStaking.add(address(_pancakeRouter));
        _excludedFromStaking.add(_pancakePairAddress);
        _excludedFromStaking.add(address(this));
        _excludedFromStaking.add(0x000000000000000000000000000000000000dEaD);
    
    }

    //Transfer functionality///

    //transfer function, every transfer runs through this function
    function _transfer(address sender, address recipient, uint256 amount) private{
        require(sender != address(0), "Transfer from zero");
        require(recipient != address(0), "Transfer to zero");
        
        //Manually Excluded adresses are transfering tax and lock free
        bool isExcluded = (_excluded.contains(sender) || _excluded.contains(recipient));
        
        //Transactions from and to the contract are always tax and lock free
        bool isContractTransfer=(sender==address(this) || recipient==address(this));
        
        //transfers between PancakeRouter and PancakePair are tax and lock free
        address pancakeRouter=address(_pancakeRouter);
        bool isLiquidityTransfer = ((sender == _pancakePairAddress && recipient == pancakeRouter) 
        || (recipient == _pancakePairAddress && sender == pancakeRouter));

        //differentiate between buy/sell/transfer to apply different taxes/restrictions
        bool isBuy=sender==_pancakePairAddress|| sender == pancakeRouter;
        bool isSell=recipient==_pancakePairAddress|| recipient == pancakeRouter;

        //Pick transfer
        if(isContractTransfer || isLiquidityTransfer || isExcluded){
            _feelessTransfer(sender, recipient, amount);
        }
        else{ 
            //once trading is enabled, it can't be turned off again
            require(tradingEnabled,"trading not yet enabled");
            _taxedTransfer(sender,recipient,amount,isBuy,isSell);
        }
    }
    //applies taxes, checks for limits, locks generates autoLP and stakingBNB, and autostakes
    function _taxedTransfer(address sender, address recipient, uint256 amount,bool isBuy,bool isSell) private{
        uint256 recipientBalance = _balances[recipient];
        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "Transfer exceeds balance");

        uint8 tax;
        if(isSell){
            if(!_excludedFromSellLock.contains(sender)){
                 //If seller sold less than sellLockTime(2h 50m) ago, sell is declined, can be disabled by Team         
                require(_sellLock[sender]<=block.timestamp||sellLockDisabled,"Seller in sellLock");
                //Sets the time sellers get locked(2 hours 50 mins by default)
                _sellLock[sender]=block.timestamp+sellLockTime;
            }
            //Sells can't exceed the sell limit(21,000 Tokens at start, can be updated to circulating supply)
            require(amount<=sellLimit,"Dump protection");
            tax=_sellTax;


        } else if(isBuy){
			if(!_excludedFromBuyLock.contains(recipient)){
                 //If buyer bought less than buyLockTime(2h 50m) ago, buy is declined, can be disabled by Team         
                require(_buyLock[recipient]<=block.timestamp||buyLockDisabled,"Buyer in buyLock");
                //Sets the time buyers get locked(2 hours 50 mins by default)
                _buyLock[recipient]=block.timestamp+buyLockTime;
            }
            //Checks If the recipient balance(excluding Taxes) would exceed Balance Limit
            require(recipientBalance+amount<=balanceLimit,"whale protection");
			require(amount <= antiWhale,"Tx amount exceeding max buy amount");
            tax=_buyTax;

        } else {//Transfer
            //withdraws BNB when sending less or equal to 1 Token
            //that way you can withdraw without connecting to any dApp.
            //might needs higher gas limit
            if(amount<=10**(_decimals)) claim(sender);
            //Checks If the recipient balance(excluding Taxes) would exceed Balance Limit
            require(recipientBalance+amount<=balanceLimit,"whale protection");
            //Transfers are disabled in sell lock, this doesn't stop someone from transfering before
            //selling, but there is no satisfying solution for that, and you would need to pax additional tax
            if(!_excludedFromSellLock.contains(sender))
                require(_sellLock[sender]<=block.timestamp||sellLockDisabled,"Sender in Lock");
            tax=_transferTax;

        }     
        //Swapping AutoLP and MarketingBNB is only possible if sender is not pancake pair, 
        //if its not manually disabled, if its not already swapping and if its a Sell to avoid
        // people from causing a large price impact from repeatedly transfering when theres a large backlog of Tokens
        if((sender!=_pancakePairAddress)&&(!manualConversion)&&(!_isSwappingContractModifier)&&isSell)
            _swapContractToken();
        //Calculates the exact token amount for each tax
        uint256 tokensToBeBurnt=_calculateFee(amount, tax, _burnTax);
        //staking and liquidity Tax get treated the same, only during conversion they get split
        uint256 contractToken=_calculateFee(amount, tax, _stakingTax+_liquidityTax);
        //Subtract the Taxed Tokens from the amount
        uint256 taxedAmount=amount-(tokensToBeBurnt + contractToken);

        //Removes token and handles staking
        _removeToken(sender,amount);
        
        //Adds the taxed tokens to the contract wallet
        _balances[address(this)] += contractToken;
        //Burns tokens
        _circulatingSupply-=tokensToBeBurnt;

        //Adds token and handles staking
        _addToken(recipient, taxedAmount);
        
        emit Transfer(sender,recipient,taxedAmount);

    }

    //Feeless transfer only transfers and autostakes
    function _feelessTransfer(address sender, address recipient, uint256 amount) private{
        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "Transfer exceeds balance");
        //Removes token and handles staking
        _removeToken(sender,amount);
        //Adds token and handles staking
        _addToken(recipient, amount);
        
        emit Transfer(sender,recipient,amount);

    }
    //Calculates the token that should be taxed
    function _calculateFee(uint256 amount, uint8 tax, uint8 taxPercent) private pure returns (uint256) {
        return (amount*tax*taxPercent) / 10000;
    }

     //BNB Autostake/////////////////////////////////////////////////////////////////////////////////////////
       //Autostake uses the balances of each holder to redistribute auto generated BNB.
    //Each transaction _addToken and _removeToken gets called for the transaction amount
    //WithdrawBNB can be used for any holder to withdraw BNB at any time, like true Staking,
    //so unlike MRAT clones you can leave and forget your Token and claim after a while

    //lock for the withdraw
    bool private _isWithdrawing;
    //Multiplier to add some accuracy to profitPerShare
    uint256 private constant DistributionMultiplier = 2**64;
    //profit for each share a holder holds, a share equals a token.
    uint256 public profitPerShare;
    //the total reward distributed through staking, for tracking purposes
    uint256 public totalStakingReward;
    //the total payout through staking, for tracking purposes
    uint256 public totalPayouts;
    
  
    uint8 public marketingShare=100;
    //balance that is claimable by the team
    uint256 public marketingBalance;

    //Mapping of the already paid out(or missed) shares of each staker
    mapping(address => uint256) private alreadyPaidShares;
    //Mapping of shares that are reserved for payout
    mapping(address => uint256) private toBePaid;

    //Contract, pancake and burnAddress are excluded, other addresses like CEX
    //can be manually excluded, excluded list is limited to 30 entries to avoid a
    //out of gas exeption during sells
    function isExcludedFromStaking(address addr) public view returns (bool){
        return _excludedFromStaking.contains(addr);
    }

    //Total shares equals circulating supply minus excluded Balances
    function _getTotalShares() public view returns (uint256){
        uint256 shares=_circulatingSupply;
        //substracts all excluded from shares, excluded list is limited to 30
        // to avoid creating a Honeypot through OutOfGas exeption
        for(uint i=0; i<_excludedFromStaking.length(); i++){
            shares-=_balances[_excludedFromStaking.at(i)];
        }
        return shares;
    }

    //adds Token to balances, adds new BNB to the toBePaid mapping and resets staking
    function _addToken(address addr, uint256 amount) private {
        //the amount of token after transfer
        uint256 newAmount=_balances[addr]+amount;
        
        if(isExcludedFromStaking(addr)){
           _balances[addr]=newAmount;
           return;
        }
        
        //gets the payout before the change
        uint256 payment=_newDividentsOf(addr);
        //resets dividents to 0 for newAmount
        alreadyPaidShares[addr] = profitPerShare * newAmount;
        //adds dividents to the toBePaid mapping
        toBePaid[addr]+=payment; 
        //sets newBalance
        _balances[addr]=newAmount;
    }
    
    
    //removes Token, adds BNB to the toBePaid mapping and resets staking
    function _removeToken(address addr, uint256 amount) private {
        //the amount of token after transfer
        uint256 newAmount=_balances[addr]-amount;
        
        if(isExcludedFromStaking(addr)){
           _balances[addr]=newAmount;
           return;
        }
        
        //gets the payout before the change
        uint256 payment=_newDividentsOf(addr);
        //sets newBalance
        _balances[addr]=newAmount;
        //resets dividents to 0 for newAmount
        alreadyPaidShares[addr] = profitPerShare * newAmount;
        //adds dividents to the toBePaid mapping
        toBePaid[addr]+=payment; 
    }
    
    
    //gets the not dividents of a staker that aren't in the toBePaid mapping 
    //returns wrong value for excluded accounts
    function _newDividentsOf(address staker) private view returns (uint256) {
        uint256 fullPayout = profitPerShare * _balances[staker];
        // if theres an overflow for some unexpected reason, return 0, instead of 
        // an exeption to still make trades possible
        if(fullPayout<alreadyPaidShares[staker]) return 0;
        return (fullPayout - alreadyPaidShares[staker]) / DistributionMultiplier;
    }

    //distributes bnb between marketing share and dividents 
    function _distributeStake(uint256 BNBamount) private {
        // Deduct marketing Tax
        uint256 marketingSplit = (BNBamount * marketingShare) / 100;
        uint256 amount = BNBamount - marketingSplit;

       marketingBalance+=marketingSplit;
       
        if (amount > 0) {
            totalStakingReward += amount;
            uint256 totalShares=_getTotalShares();
            //when there are 0 shares, add everything to marketing budget
            if (totalShares == 0) {
                marketingBalance += amount;
            }else{
                //Increases profit per share based on current total shares
                profitPerShare += ((amount * DistributionMultiplier) / totalShares);
            }
        }
    }
    event OnWithdrawXRP(uint256 amount, address recipient);
    
    //withdraws all dividents of address
    function claim(address addr) private{
        require(!_isWithdrawing);
        _isWithdrawing=true;
        uint256 amount;
        if(isExcludedFromStaking(addr)){
            //if excluded just withdraw remaining toBePaid BNB
            amount=toBePaid[addr];
            toBePaid[addr]=0;
        }
        else{
            uint256 newAmount=_newDividentsOf(addr);
            //sets payout mapping to current amount
            alreadyPaidShares[addr] = profitPerShare * _balances[addr];
            //the amount to be paid 
            amount=toBePaid[addr]+newAmount;
            toBePaid[addr]=0;
        }
        if(amount==0){//no withdraw if 0 amount
            _isWithdrawing=false;
            return;
        }
        totalPayouts+=amount;
        address[] memory path = new address[](2);
        path[0] = _pancakeRouter.WETH(); //BNB
        path[1] = 0x1D2F0da169ceB9fC7B3144628dB156f3F6c60dBE;  //Binance-Peg XRP Token

        _pancakeRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{value: amount}(
        0,
        path,
        addr,
        block.timestamp);
        
        emit OnWithdrawXRP(amount, addr);
        _isWithdrawing=false;
    }

    //Swap Contract Tokens//////////////////////////////////////////////////////////////////////////////////

    //tracks auto generated BNB, useful for ticker etc
    uint256 public totalLPBNB;
    //Locks the swap if already swapping
    bool private _isSwappingContractModifier;
    modifier lockTheSwap {
        _isSwappingContractModifier = true;
        _;
        _isSwappingContractModifier = false;
    }

    //swaps the token on the contract for Marketing BNB and LP Token.
    //always swaps the sellLimit of token to avoid a large price impact
    function _swapContractToken() private lockTheSwap{
        uint256 contractBalance=_balances[address(this)];
        uint16 totalTax=_liquidityTax+_stakingTax;
        uint256 tokenToSwap = 15000000 * 10**_decimals;
        //only swap if contractBalance is larger than tokenToSwap, and totalTax is unequal to 0
        if(contractBalance<tokenToSwap||totalTax==0){
            return;
        }
        //splits the token in TokenForLiquidity and tokenForMarketing
        uint256 tokenForLiquidity=(tokenToSwap*_liquidityTax)/totalTax;
        uint256 tokenForMarketing= tokenToSwap-tokenForLiquidity;

        //splits tokenForLiquidity in 2 halves
        uint256 liqToken=tokenForLiquidity/2;
        uint256 liqBNBToken=tokenForLiquidity-liqToken;

        //swaps marktetingToken and the liquidity token half for BNB
        uint256 swapToken=liqBNBToken+tokenForMarketing;
        //Gets the initial BNB balance, so swap won't touch any staked BNB
        uint256 initialBNBBalance = address(this).balance;
        _swapTokenForBNB(swapToken);
        uint256 newBNB=(address(this).balance - initialBNBBalance);
        //calculates the amount of BNB belonging to the LP-Pair and converts them to LP
        uint256 liqBNB = (newBNB*liqBNBToken)/swapToken;
        _addLiquidity(liqToken, liqBNB);
        //Get the BNB balance after LP generation to get the
        //exact amount of token left for Staking
        uint256 distributeBNB=(address(this).balance - initialBNBBalance);
        //distributes remaining BNB between stakers and Marketing
        _distributeStake(distributeBNB);
    }
    //swaps tokens on the contract for BNB
    function _swapTokenForBNB(uint256 amount) private {
        _approve(address(this), address(_pancakeRouter), amount);
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = _pancakeRouter.WETH();

        _pancakeRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amount,
            0,
            path,
            address(this),
            block.timestamp
        );
    }
    //Adds Liquidity directly to the contract where LP are locked(unlike safemoon forks, that transfer it to the owner)
    function _addLiquidity(uint256 tokenamount, uint256 bnbamount) private {
        totalLPBNB+=bnbamount;
        _approve(address(this), address(_pancakeRouter), tokenamount);
        _pancakeRouter.addLiquidityETH{value: bnbamount}(
            address(this),
            tokenamount,
            0,
            0,
            address(this),
            block.timestamp
        );
    }

    //public functions /////////////////////////////////////////////////////////////////////////////////////

    function getLiquidityReleaseTimeInSeconds() public view returns (uint256){
        if(block.timestamp<_liquidityUnlockTime){
            return _liquidityUnlockTime-block.timestamp;
        }
        return 0;
    }

    function getBurnedTokens() public view returns(uint256){
        return (InitialSupply-_circulatingSupply)/10**_decimals;
    }

    function getLimits() public view returns(uint256 balance, uint256 sell){
        return(balanceLimit/10**_decimals, sellLimit/10**_decimals);
    }

    function getTaxes() public view returns(uint256 burnTax,uint256 liquidityTax,uint256 marketingTax, uint256 buyTax, uint256 sellTax, uint256 transferTax){
        return (_burnTax,_liquidityTax,_stakingTax,_buyTax,_sellTax,_transferTax);
    }

    //How long is a given address still locked from selling
    function getAddressSellLockTimeInSeconds(address AddressToCheck) public view returns (uint256){
       uint256 lockTime=_sellLock[AddressToCheck];
       if(lockTime<=block.timestamp)
       {
           return 0;
       }
       return lockTime-block.timestamp;
    }
    function getSellLockTimeInSeconds() public view returns(uint256){
        return sellLockTime;
    }
	
    //How long is a given address still locked from buying
	function getAddressBuyLockTimeInSeconds(address AddressToCheck) public view returns (uint256){
       uint256 lockTime=_buyLock[AddressToCheck];
       if(lockTime<=block.timestamp)
       {
           return 0;
       }
       return lockTime-block.timestamp;
    }
    function getBuyLockTimeInSeconds() public view returns(uint256){
        return buyLockTime;
    }
    
    //Functions every wallet can call
    //Resets sell lock of caller to the default sellLockTime should something go very wrong
    function AddressResetSellLock() public{
        _sellLock[msg.sender]=block.timestamp+sellLockTime;
    }
	
	//Resets buy lock of caller to the default buyLockTime should something go very wrong
    function AddressResetBuyLock() public{
        _buyLock[msg.sender]=block.timestamp+buyLockTime;
	
    }
    function getDividents(address addr) public view returns (uint256){
        if(isExcludedFromStaking(addr)) return toBePaid[addr];
        return _newDividentsOf(addr)+toBePaid[addr];
    }

    //Settings//////////////////////////////////////////////////////////////////////////////////////////////
 
    bool public sellLockDisabled;
    uint256 public sellLockTime;
	bool public buyLockDisabled;
    uint256 public buyLockTime;
    bool public manualConversion; 

    function TeamWithdrawALLMarketingBNB() public onlyOwner{
        uint256 amount=marketingBalance;
        marketingBalance=0;
        payable(TeamWallet).transfer((amount*75) / 100);
        payable(walletTwo).transfer((amount*25) / 100);
    } 
    function TeamWithdrawXMarketingBNB(uint256 amount) public onlyOwner{
        require(amount<=marketingBalance);
        marketingBalance-=amount;
        payable(TeamWallet).transfer((amount*75) / 100);
        payable(walletTwo).transfer((amount*25) / 100);
    } 

    //switches autoLiquidity and marketing BNB generation during transfers
    function TeamSwitchManualBNBConversion(bool manual) public onlyOwner{
        manualConversion=manual;
    }
	
	function TeamChangeAntiWhale(uint256 newAntiWhale) public onlyOwner{
      antiWhale=newAntiWhale * 10**_decimals;
    }
    
    function TeamChangeTeamWallet(address newTeamWallet) public onlyOwner{
      TeamWallet=payable(newTeamWallet);
    }
    
    function TeamChangeWalletTwo(address newWalletTwo) public onlyOwner{
      walletTwo=payable(newWalletTwo);
    }

    //Disables the timeLock after selling for everyone
    function TeamDisableSellLock(bool disabled) public onlyOwner{
        sellLockDisabled=disabled;
    }
	
	//Disables the timeLock after buying for everyone
    function TeamDisableBuyLock(bool disabled) public onlyOwner{
        buyLockDisabled=disabled;
    }

    //Sets SellLockTime, needs to be lower than MaxSellLockTime
    function TeamSetSellLockTime(uint256 sellLockSeconds)public onlyOwner{
            require(sellLockSeconds<=MaxSellLockTime,"Sell Lock time too high");
            sellLockTime=sellLockSeconds;
    } 
	
	//Sets BuyLockTime, needs to be lower than MaxBuyLockTime
    function TeamSetBuyLockTime(uint256 buyLockSeconds)public onlyOwner{
            require(buyLockSeconds<=MaxBuyLockTime,"Buy Lock time too high");
            buyLockTime=buyLockSeconds;
    } 
    
    //Allows wallet exclusion to be added after launch
    function AddWalletExclusion(address exclusionAdd) public onlyOwner{
        _excluded.add(exclusionAdd);
    }
    
    //Sets Taxes, is limited by MaxTax(20%) to make it impossible to create honeypot
    function TeamSetTaxes(uint8 burnTaxes, uint8 liquidityTaxes, uint8 stakingTaxes,uint8 buyTax, uint8 sellTax, uint8 transferTax) public onlyOwner{
        uint8 totalTax=burnTaxes+liquidityTaxes+stakingTaxes;
        require(totalTax==100, "burn+liq+marketing needs to equal 100%");

        _burnTax=burnTaxes;
        _liquidityTax=liquidityTaxes;
        _stakingTax=stakingTaxes;
        
        _buyTax=buyTax;
        _sellTax=sellTax;
        _transferTax=transferTax;
    }

    //How much of the staking tax should be allocated for marketing
    function TeamChangeMarketingShare(uint8 newShare) public onlyOwner{
        require(newShare<=100); 
        marketingShare=newShare;
    }
    //manually converts contract token to LP and staking BNB
    function TeamCreateLPandBNB() public onlyOwner{
    _swapContractToken();
    }
    
     //Limits need to be at least target, to avoid setting value to 0(avoid potential Honeypot)
    function TeamUpdateLimits(uint256 newBalanceLimit, uint256 newSellLimit) public onlyOwner{
        //SellLimit needs to be below 1% to avoid a Large Price impact when generating auto LP
        require(newSellLimit<_circulatingSupply/100);
        //Adds decimals to limits
        newBalanceLimit=newBalanceLimit*10**_decimals;
        newSellLimit=newSellLimit*10**_decimals;
        //Calculates the target Limits based on supply
        uint256 targetBalanceLimit=_circulatingSupply/BalanceLimitDivider;
        uint256 targetSellLimit=_circulatingSupply/SellLimitDivider;

        require((newBalanceLimit>=targetBalanceLimit), 
        "newBalanceLimit needs to be at least target");
        require((newSellLimit>=targetSellLimit), 
        "newSellLimit needs to be at least target");

        balanceLimit = newBalanceLimit;
        sellLimit = newSellLimit;     
    }

    
    //Setup Functions///////////////////////////////////////////////////////////////////////////////////////
    
    bool public tradingEnabled;
    address private _liquidityTokenAddress;
    //Enables trading for everyone
    function SetupEnableTrading() public onlyOwner{
        tradingEnabled=true;
    }
    //Sets up the LP-Token Address required for LP Release
    function SetupLiquidityTokenAddress(address liquidityTokenAddress) public onlyOwner{
        _liquidityTokenAddress=liquidityTokenAddress;
    }

    //Liquidity Lock////////////////////////////////////////////////////////////////////////////////////////
    //the timestamp when Liquidity unlocks
    uint256 private _liquidityUnlockTime;

    function TeamUnlockLiquidityInSeconds(uint256 secondsUntilUnlock) public onlyOwner{
        _prolongLiquidityLock(secondsUntilUnlock+block.timestamp);
    }
    function _prolongLiquidityLock(uint256 newUnlockTime) private{
        // require new unlock time to be longer than old one
        require(newUnlockTime>_liquidityUnlockTime);
        _liquidityUnlockTime=newUnlockTime;
    }

    //Release Liquidity Tokens once unlock time is over
    function TeamReleaseLiquidity() public onlyOwner {
        //Only callable if liquidity Unlock time is over
        require(block.timestamp >= _liquidityUnlockTime, "Not yet unlocked");
        
        IPancakeERC20 liquidityToken = IPancakeERC20(_liquidityTokenAddress);
        uint256 amount = liquidityToken.balanceOf(address(this));

        //Liquidity release if something goes wrong at start
        liquidityToken.transfer(TeamWallet, amount);
        
    }
    //Removes Liquidity once unlock Time is over, 
    function TeamRemoveLiquidity(bool addToStaking) public onlyOwner{
        //Only callable if liquidity Unlock time is over
        require(block.timestamp >= _liquidityUnlockTime, "Not yet unlocked");
        _liquidityUnlockTime=block.timestamp+DefaultLiquidityLockTime;
        IPancakeERC20 liquidityToken = IPancakeERC20(_liquidityTokenAddress);
        uint256 amount = liquidityToken.balanceOf(address(this));

        liquidityToken.approve(address(_pancakeRouter),amount);
        //Removes Liquidity and either distributes liquidity BNB to stakers, or 
        // adds them to marketing Balance
        //Token will be converted
        //to Liquidity and Staking BNB again
        uint256 initialBNBBalance = address(this).balance;
        _pancakeRouter.removeLiquidityETHSupportingFeeOnTransferTokens(
            address(this),
            amount,
            0,
            0,
            address(this),
            block.timestamp
            );
        uint256 newBNBBalance = address(this).balance-initialBNBBalance;
        if(addToStaking){
            _distributeStake(newBNBBalance);
        }
        else{
            marketingBalance+=newBNBBalance;
        }

    }
    //Releases all remaining BNB on the contract wallet, so BNB wont be burned
    function TeamRemoveRemainingBNB() public onlyOwner{
        require(block.timestamp >= _liquidityUnlockTime, "Not yet unlocked");
        _liquidityUnlockTime=block.timestamp+DefaultLiquidityLockTime;
        (bool sent,) =TeamWallet.call{value: (address(this).balance)}("");
        require(sent);
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //external//////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    receive() external payable {}
    fallback() external payable {}
    // IBEP20

    function getOwner() external view override returns (address) {
        return owner();
    }

    function name() external pure override returns (string memory) {
        return _name;
    }

    function symbol() external pure override returns (string memory) {
        return _symbol;
    }

    function decimals() external pure override returns (uint8) {
        return _decimals;
    }

    function totalSupply() external view override returns (uint256) {
        return _circulatingSupply;
    }

    function balanceOf(address account) external view override returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) external override returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    function allowance(address _owner, address spender) external view override returns (uint256) {
        return _allowances[_owner][spender];
    }

    function approve(address spender, uint256 amount) external override returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }
    function _approve(address owner, address spender, uint256 amount) private {
        require(owner != address(0), "Approve from zero");
        require(spender != address(0), "Approve to zero");

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

    function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][msg.sender];
        require(currentAllowance >= amount, "Transfer > allowance");

        _approve(sender, msg.sender, currentAllowance - amount);
        return true;
    }

    // IBEP20 - Helpers

    function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
        uint256 currentAllowance = _allowances[msg.sender][spender];
        require(currentAllowance >= subtractedValue, "<0 allowance");

        _approve(msg.sender, spender, currentAllowance - subtractedValue);
        return true;
    }

}

Contract Security Audit

Contract ABI

[{"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":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"}],"name":"OnWithdrawXRP","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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"exclusionAdd","type":"address"}],"name":"AddWalletExclusion","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"AddressResetBuyLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"AddressResetSellLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"BalanceLimitDivider","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"InitialSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MaxBuyLockTime","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MaxSellLockTime","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SellLimitDivider","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SetupEnableTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"liquidityTokenAddress","type":"address"}],"name":"SetupLiquidityTokenAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newAntiWhale","type":"uint256"}],"name":"TeamChangeAntiWhale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"newShare","type":"uint8"}],"name":"TeamChangeMarketingShare","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newTeamWallet","type":"address"}],"name":"TeamChangeTeamWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newWalletTwo","type":"address"}],"name":"TeamChangeWalletTwo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"TeamCreateLPandBNB","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"disabled","type":"bool"}],"name":"TeamDisableBuyLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"disabled","type":"bool"}],"name":"TeamDisableSellLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"TeamReleaseLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"addToStaking","type":"bool"}],"name":"TeamRemoveLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"TeamRemoveRemainingBNB","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"buyLockSeconds","type":"uint256"}],"name":"TeamSetBuyLockTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"sellLockSeconds","type":"uint256"}],"name":"TeamSetSellLockTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"burnTaxes","type":"uint8"},{"internalType":"uint8","name":"liquidityTaxes","type":"uint8"},{"internalType":"uint8","name":"stakingTaxes","type":"uint8"},{"internalType":"uint8","name":"buyTax","type":"uint8"},{"internalType":"uint8","name":"sellTax","type":"uint8"},{"internalType":"uint8","name":"transferTax","type":"uint8"}],"name":"TeamSetTaxes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"manual","type":"bool"}],"name":"TeamSwitchManualBNBConversion","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"secondsUntilUnlock","type":"uint256"}],"name":"TeamUnlockLiquidityInSeconds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newBalanceLimit","type":"uint256"},{"internalType":"uint256","name":"newSellLimit","type":"uint256"}],"name":"TeamUpdateLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"TeamWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TeamWithdrawALLMarketingBNB","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TeamWithdrawXMarketingBNB","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"_getTotalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"balanceLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyLockDisabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyLockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","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":"AddressToCheck","type":"address"}],"name":"getAddressBuyLockTimeInSeconds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"AddressToCheck","type":"address"}],"name":"getAddressSellLockTimeInSeconds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBurnedTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBuyLockTimeInSeconds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getDividents","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLimits","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"sell","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLiquidityReleaseTimeInSeconds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSellLockTimeInSeconds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTaxes","outputs":[{"internalType":"uint256","name":"burnTax","type":"uint256"},{"internalType":"uint256","name":"liquidityTax","type":"uint256"},{"internalType":"uint256","name":"marketingTax","type":"uint256"},{"internalType":"uint256","name":"buyTax","type":"uint256"},{"internalType":"uint256","name":"sellTax","type":"uint256"},{"internalType":"uint256","name":"transferTax","type":"uint256"}],"stateMutability":"view","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":"addr","type":"address"}],"name":"isExcludedFromStaking","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manualConversion","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingShare","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"profitPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sellLockDisabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sellLockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalLPBNB","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalPayouts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStakingReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"walletTwo","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Deployed ByteCode Sourcemap

27543:33617:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58814:94;;;;;;;;;;-1:-1:-1;58895:5:0;;;;;;;;;;;;-1:-1:-1;;;58895:5:0;;;;58814:94;;;;;;;:::i;:::-;;;;;;;;39439:31;;;;;;;;;;-1:-1:-1;39439:31:0;;;;;;;;;;;17797:4:1;17785:17;;;17767:36;;17755:2;17740:18;39439:31:0;17722:87:1;59699:161:0;;;;;;;;;;-1:-1:-1;59699:161:0;;;;;:::i;:::-;;:::i;:::-;;;6090:14:1;;6083:22;6065:41;;6053:2;6038:18;59699:161:0;6020:92:1;28592:43:0;;;;;;;;;;;;28632:3;28592:43;;;;;15765:6:1;15753:19;;;15735:38;;15723:2;15708:18;28592:43:0;15690:89:1;49319:102:0;;;;;;;;;;-1:-1:-1;49401:12:0;;49319:102;;;15930:25:1;;;15918:2;15903:18;49319:102:0;15885:76:1;49766:100:0;;;;;;;;;;-1:-1:-1;49847:11:0;;49766:100;;51980:104;;;;;;;;;;-1:-1:-1;51980:104:0;;;;;:::i;:::-;;:::i;59124:108::-;;;;;;;;;;-1:-1:-1;59206:18:0;;59124:108;;28316:65;;;;;;;;;;;;;:::i;60173:392::-;;;;;;;;;;-1:-1:-1;60173:392:0;;;;;:::i;:::-;;:::i;29266:76::-;;;;;;;;;;-1:-1:-1;29266:76:0;;;;-1:-1:-1;;;;;29266:76:0;;;;;;-1:-1:-1;;;;;4990:32:1;;;4972:51;;4960:2;4945:18;29266:76:0;4927:102:1;48725:244:0;;;;;;;;;;-1:-1:-1;48896:8:0;;48725:244;;;48896:8;;;;;;17372:25:1;;48905:13:0;;;;;17428:2:1;17413:18;;17406:34;-1:-1:-1;;;48919:11:0;;;;17456:18:1;;;17449:34;;;;48931:7:0;;;17514:2:1;17499:18;;17492:34;48896:8:0;48939;;;;17557:3:1;17542:19;;17535:35;48948:12:0;;;;;17601:3:1;17586:19;;17579:35;17359:3;17344:19;48725:244:0;17326:294:1;51066:269:0;;;;;;;;;;-1:-1:-1;51066:269:0;;;;;:::i;:::-;;:::i;55677:158::-;;;;;;;;;;-1:-1:-1;55677:158:0;;;;;:::i;:::-;;:::i;50705:27::-;;;;;;;;;;-1:-1:-1;50705:27:0;;;;;;;;28477:45;;;;;;;;;;;;28519:3;28477:45;;59022:94;;;;;;;;;;-1:-1:-1;28308:1:0;59022:94;;50327:191;;;;;;;;;;-1:-1:-1;50327:191:0;;;;;:::i;:::-;;:::i;28778:49::-;;;;;;;;;;;;28818:9;28778:49;;60600:205;;;;;;;;;;-1:-1:-1;60600:205:0;;;;;:::i;:::-;;:::i;56136:478::-;;;;;;;;;;;;;:::i;39395:27::-;;;;;;;;;;;;;;;;50739:26;;;;;;;;;;;;;;;;50010:107;;;;;;;;;;;;;:::i;55060:26::-;;;;;;;;;;-1:-1:-1;55060:26:0;;;;;;;;;;;55324:146;;;;;;;;;;-1:-1:-1;55324:146:0;;;;;:::i;:::-;;:::i;29812:46::-;;;;;;;;;;;;;;;;53066:492;;;;;;;;;;-1:-1:-1;53066:492:0;;;;;:::i;:::-;;:::i;39522:31::-;;;;;;;;;;;;;;;;29182:77;;;;;;;;;;-1:-1:-1;29182:77:0;;;;-1:-1:-1;;;;;29182:77:0;;;48568:149;;;;;;;;;;;;;:::i;:::-;;;;17006:25:1;;;17062:2;17047:18;;17040:34;;;;16979:18;48568:149:0;16961:119:1;59240:121:0;;;;;;;;;;-1:-1:-1;59240:121:0;;;;;:::i;:::-;-1:-1:-1;;;;;59335:18:0;59308:7;59335:18;;;:9;:18;;;;;;;59240:121;9399:140;;;;;;;;;;;;;:::i;40004:132::-;;;;;;;;;;-1:-1:-1;40004:132:0;;;;;:::i;:::-;;:::i;53635:142::-;;;;;;;;;;-1:-1:-1;53635:142:0;;;;;:::i;:::-;;:::i;29756:49::-;;;;;;;;;;;;;;;;55174:84;;;;;;;;;;;;;:::i;50214:107::-;;;;;;;;;;;;;:::i;39181:29::-;;;;;;;;;;;;;;;;50772:28;;;;;;;;;;-1:-1:-1;50772:28:0;;;;;;;;49038:275;;;;;;;;;;-1:-1:-1;49038:275:0;;;;;:::i;:::-;;:::i;50639:28::-;;;;;;;;;;-1:-1:-1;50639:28:0;;;;;;;;;;;58712:94;;;;;;;;;;-1:-1:-1;58764:7:0;8823:6;-1:-1:-1;;;;;8823:6:0;58712:94;;45016:25;;;;;;;;;;;;;;;;51420:110;;;;;;;;;;-1:-1:-1;51420:110:0;;;;;:::i;:::-;;:::i;58916:98::-;;;;;;;;;;-1:-1:-1;58999:7:0;;;;;;;;;;;;-1:-1:-1;;;58999:7:0;;;;58916:98;;51670:119;;;;;;;;;;-1:-1:-1;51670:119:0;;;;;:::i;:::-;;:::i;54035:895::-;;;;;;;;;;-1:-1:-1;54035:895:0;;;;;:::i;:::-;;:::i;60813:342::-;;;;;;;;;;-1:-1:-1;60813:342:0;;;;;:::i;:::-;;:::i;59369:167::-;;;;;;;;;;-1:-1:-1;59369:167:0;;;;;:::i;:::-;;:::i;52145:102::-;;;;;;;;;;-1:-1:-1;52145:102:0;;;;;:::i;:::-;;:::i;48203:220::-;;;;;;;;;;;;;:::i;48431:129::-;;;;;;;;;;;;;:::i;52856:112::-;;;;;;;;;;-1:-1:-1;52856:112:0;;;;;:::i;:::-;;:::i;52320:202::-;;;;;;;;;;-1:-1:-1;52320:202:0;;;;;:::i;:::-;;:::i;51801:115::-;;;;;;;;;;-1:-1:-1;51801:115:0;;;;;:::i;:::-;;:::i;51536:122::-;;;;;;;;;;-1:-1:-1;51536:122:0;;;;;:::i;:::-;;:::i;59544:147::-;;;;;;;;;;-1:-1:-1;59544:147:0;;;;;:::i;:::-;-1:-1:-1;;;;;59655:19:0;;;59628:7;59655:19;;;:11;:19;;;;;;;;:28;;;;;;;;;;;;;59544:147;52592:195;;;;;;;;;;-1:-1:-1;52592:195:0;;;;;:::i;:::-;;:::i;40214:411::-;;;;;;;;;;;;;:::i;49487:273::-;;;;;;;;;;-1:-1:-1;49487:273:0;;;;;:::i;:::-;;:::i;56672:1219::-;;;;;;;;;;-1:-1:-1;56672:1219:0;;;;;:::i;:::-;;:::i;39292:33::-;;;;;;;;;;;;;;;;57977:309;;;;;;;;;;;;;:::i;9694:236::-;;;;;;;;;;-1:-1:-1;9694:236:0;;;;;:::i;:::-;;:::i;50674:27::-;;;;;;;;;;;;;;;;50810:249;;;;;;;;;;;;;:::i;53845:81::-;;;;;;;;;;;;;:::i;59699:161::-;59776:4;59793:37;59802:10;59814:7;59823:6;59793:8;:37::i;:::-;-1:-1:-1;59848:4:0;59699:161;;;;;:::o;51980:104::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;;;;;;;;;52051:16:::1;:25:::0;;;::::1;;;;-1:-1:-1::0;;52051:25:0;;::::1;::::0;;;::::1;::::0;;51980:104::o;28316:65::-;28368:13;28308:1;28368:2;:13;:::i;:::-;28355:26;;:10;:26;:::i;:::-;28316:65;:::o;60173:392::-;60273:4;60290:36;60300:6;60308:9;60319:6;60290:9;:36::i;:::-;-1:-1:-1;;;;;60366:19:0;;60339:24;60366:19;;;:11;:19;;;;;;;;60386:10;60366:31;;;;;;;;60416:26;;;;60408:59;;;;-1:-1:-1;;;60408:59:0;;10751:2:1;60408:59:0;;;10733:21:1;10790:2;10770:18;;;10763:30;-1:-1:-1;;;10809:18:1;;;10802:50;10869:18;;60408:59:0;10723:170:1;60408:59:0;60480:55;60489:6;60497:10;60509:25;60528:6;60509:16;:25;:::i;:::-;60480:8;:55::i;:::-;-1:-1:-1;60553:4:0;;60173:392;-1:-1:-1;;;;60173:392:0:o;51066:269::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;51160:16:::1;;51152:6;:24;;51144:33;;;::::0;::::1;;51206:6;51188:16;;:24;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;51231:10:0::1;::::0;-1:-1:-1;;;;;51231:10:0::1;51223:47;51266:3;51253:9;:6:::0;51260:2:::1;51253:9;:::i;:::-;51252:17;;;;:::i;:::-;51223:47;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;51289:9:0::1;::::0;-1:-1:-1;;;;;51289:9:0::1;51281:46;51323:3;51310:9;:6:::0;51317:2:::1;51310:9;:::i;:::-;51309:17;;;;:::i;:::-;51281:46;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;51066:269:::0;:::o;55677:158::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;55770:57:::1;55792:34;55811:15;55792:18:::0;:34:::1;:::i;:::-;55770:21;:57::i;:::-;55677:158:::0;:::o;50327:191::-;50384:7;50406:27;50428:4;50406:21;:27::i;:::-;50403:53;;;-1:-1:-1;;;;;;50442:14:0;;;;;:8;:14;;;;;;;50327:191::o;50403:53::-;-1:-1:-1;;;;;50496:14:0;;;;;;:8;:14;;;;;;50474:21;50505:4;50474:15;:21::i;:::-;:36;;;;:::i;60600:205::-;60708:10;60682:4;60729:23;;;:11;:23;;;;;;;;-1:-1:-1;;;;;60729:32:0;;;;;;;;;;60682:4;;60699:76;;60720:7;;60729:45;;60764:10;;60729:45;:::i;56136:478::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;56281:20:::1;;56262:15;:39;;56254:68;;;;-1:-1:-1::0;;;56254:68:0::1;;;;;;;:::i;:::-;56388:22;::::0;56439:39:::1;::::0;-1:-1:-1;;;56439:39:0;;56472:4:::1;56439:39;::::0;::::1;4972:51:1::0;56388:22:0;;;::::1;-1:-1:-1::0;;;;;56388:22:0::1;::::0;56343:28:::1;::::0;56388:22;;56439:24:::1;::::0;4945:18:1;;56439:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56577:10;::::0;56553:43:::1;::::0;-1:-1:-1;;;56553:43:0;;-1:-1:-1;;;;;56577:10:0;;::::1;56553:43;::::0;::::1;5208:51:1::0;5275:18;;;5268:34;;;56422:56:0;;-1:-1:-1;56553:23:0;::::1;::::0;::::1;::::0;5181:18:1;;56553:43:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;9039:1;;56136:478::o:0;50010:107::-;50097:12;;50081:28;;:15;:28;:::i;:::-;50069:10;50059:21;;;;:9;:21;;;;;:50;50010:107::o;55324:146::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;55418:22:::1;:44:::0;;-1:-1:-1;;;;;55418:44:0;;::::1;::::0;::::1;-1:-1:-1::0;;;;;;55418:44:0;;::::1;::::0;;;::::1;::::0;;55324:146::o;53066:492::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;53221:14:::1;53261:12:::0;53236:24:::1;53246:14:::0;53236:9;:24:::1;:::i;:::-;:37;;;;:::i;:::-;53221:52;;53292:8;:13;;53302:3;53292:13;53284:64;;;::::0;-1:-1:-1;;;53284:64:0;;11789:2:1;53284:64:0::1;::::0;::::1;11771:21:1::0;11828:2;11808:18;;;11801:30;11867:34;11847:18;;;11840:62;-1:-1:-1;;;11918:18:1;;;11911:36;11964:19;;53284:64:0::1;11761:228:1::0;53284:64:0::1;-1:-1:-1::0;53361:8:0::1;:18:::0;;::::1;53526:24:::0;;::::1;::::0;::::1;-1:-1:-1::0;;53499:16:0;;::::1;53361:18;53499:16;-1:-1:-1::0;;53429:24:0;;::::1;-1:-1:-1::0;;;53429:24:0::1;53499:16:::0;;;;-1:-1:-1;;53390:28:0;;::::1;::::0;::::1;-1:-1:-1::0;;53361:18:0;;::::1;::::0;::::1;53390:28:::0;;;;-1:-1:-1;;53390:28:0;;;;;;;;;;::::1;53499:16:::0;;;;;;;;53474:14;::::1;53499:16:::0;;;;;;;::::1;53526:24;::::0;;;::::1;::::0;;53066:492::o;48568:149::-;48609:15;;48670:13;28308:1;48670:2;:13;:::i;:::-;48657:12;;:26;;;;:::i;:::-;48695:13;28308:1;48695:2;:13;:::i;:::-;48685:9;;:23;;;;:::i;:::-;48650:59;;;;48568:149;;:::o;9399:140::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;9498:1:::1;9482:6:::0;;9461:40:::1;::::0;-1:-1:-1;;;;;9482:6:0;;::::1;::::0;9461:40:::1;::::0;9498:1;;9461:40:::1;9529:1;9512:19:::0;;-1:-1:-1;;;;;;9512:19:0::1;::::0;;9399:140::o;40004:132::-;40070:4;40093:35;:20;40123:4;40093:29;:35::i;53635:142::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;53730:3:::1;53720:8;:13;;;;53712:22;;;::::0;::::1;;53746:14;:23:::0;;-1:-1:-1;;53746:23:0::1;;::::0;;;::::1;::::0;;;::::1;::::0;;53635:142::o;55174:84::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;55231:14:::1;:19:::0;;-1:-1:-1;;55231:19:0::1;;;::::0;;55174:84::o;50214:107::-;50299:11;;50283:27;;:15;:27;:::i;:::-;50271:10;50262:20;;;;:8;:20;;;;;:48;50214:107::o;49038:275::-;-1:-1:-1;;;;;49159:25:0;;49124:7;49159:25;;;:9;:25;;;;;;49207:15;49197:25;;49194:71;;-1:-1:-1;49253:1:0;;49038:275;-1:-1:-1;;49038:275:0:o;49194:71::-;49281:24;49290:15;49281:8;:24;:::i;:::-;49274:31;49038:275;-1:-1:-1;;;49038:275:0:o;58791:7::-;58784:14;;58712:94;:::o;51420:110::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;51499:16:::1;:23:::0;;-1:-1:-1;;51499:23:0::1;::::0;::::1;;::::0;;;::::1;::::0;;51420:110::o;51670:119::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;51748:10:::1;:33:::0;;-1:-1:-1;;;;;;51748:33:0::1;-1:-1:-1::0;;;;;51748:33:0;;;::::1;::::0;;;::::1;::::0;;51670:119::o;54035:895::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;54271:3:::1;54252:18;;:22;;;;:::i;:::-;54239:12;:35;54231:44;;;::::0;::::1;;54353:13;28308:1;54353:2;:13;:::i;:::-;54337:29;::::0;:15;:29:::1;:::i;:::-;54321:45:::0;-1:-1:-1;54403:13:0::1;28308:1;54403:2;:13;:::i;:::-;54390:26;::::0;:12;:26:::1;:::i;:::-;54377:39;;54483:26;28519:3;54510:38;;:18;;:38;;;;:::i;:::-;54483:65;;54559:23;28632:3;54583:35;;:18;;:35;;;;:::i;:::-;54559:59;;54657:18;54640:15;:35;;54631:103;;;::::0;-1:-1:-1;;;54631:103:0;;9297:2:1;54631:103:0::1;::::0;::::1;9279:21:1::0;9336:2;9316:18;;;9309:30;9375:34;9355:18;;;9348:62;-1:-1:-1;;;9426:18:1;;;9419:41;9477:19;;54631:103:0::1;9269:233:1::0;54631:103:0::1;54768:15;54754:12;:29;;54745:94;;;::::0;-1:-1:-1;;;54745:94:0;;12540:2:1;54745:94:0::1;::::0;::::1;12522:21:1::0;12579:2;12559:18;;;12552:30;12618:34;12598:18;;;12591:62;-1:-1:-1;;;12669:18:1;;;12662:38;12717:19;;54745:94:0::1;12512:230:1::0;54745:94:0::1;-1:-1:-1::0;;54852:12:0::1;:30:::0;;;;54893:9:::1;:24:::0;54035:895::o;60813:342::-;60956:10;60900:4;60944:23;;;:11;:23;;;;;;;;-1:-1:-1;;;;;60944:32:0;;;;;;;;;;60995:35;;;;60987:60;;;;-1:-1:-1;;;60987:60:0;;15105:2:1;60987:60:0;;;15087:21:1;15144:2;15124:18;;;15117:30;-1:-1:-1;;;15163:18:1;;;15156:42;15215:18;;60987:60:0;15077:162:1;60987:60:0;61060:65;61069:10;61081:7;61090:34;61109:15;61090:16;:34;:::i;61060:65::-;-1:-1:-1;61143:4:0;;60813:342;-1:-1:-1;;;60813:342:0:o;59369:167::-;59449:4;59466:40;59476:10;59488:9;59499:6;59466:9;:40::i;52145:102::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;52215:15:::1;:24:::0;;-1:-1:-1;;52215:24:0::1;::::0;::::1;;::::0;;;::::1;::::0;;52145:102::o;48203:220::-;48268:7;48306:20;;48290:15;:36;48287:110;;;48370:15;48349:20;;:36;;;;:::i;48287:110::-;-1:-1:-1;48414:1:0;;48203:220::o;48431:129::-;48478:7;48539:13;28308:1;48539:2;:13;:::i;:::-;48519:18;;28368:13;28308:1;28368:2;:13;:::i;:::-;28355:26;;:10;:26;:::i;:::-;48505:32;;;;:::i;:::-;48504:48;;;;:::i;52856:112::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;52933:27:::1;:9;52947:12:::0;52933:13:::1;:27::i;52320:202::-:0;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;52412:32;;52404:67:::1;;;::::0;-1:-1:-1;;;52404:67:0;;14753:2:1;52404:67:0::1;::::0;::::1;14735:21:1::0;14792:2;14772:18;;;14765:30;14831:25;14811:18;;;14804:53;14874:18;;52404:67:0::1;14725:173:1::0;52404:67:0::1;52486:12;:28:::0;52320:202::o;51801:115::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;51877:9:::1;:31:::0;;-1:-1:-1;;;;;;51877:31:0::1;-1:-1:-1::0;;;;;51877:31:0;;;::::1;::::0;;;::::1;::::0;;51801:115::o;51536:122::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;51637:13:::1;28308:1;51637:2;:13;:::i;:::-;51622:28;::::0;:12;:28:::1;:::i;:::-;51612:9;:38:::0;-1:-1:-1;51536:122:0:o;52592:195::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;52682:30;;52674:64:::1;;;::::0;-1:-1:-1;;;52674:64:0;;10400:2:1;52674:64:0::1;::::0;::::1;10382:21:1::0;10439:2;10419:18;;;10412:30;-1:-1:-1;;;10458:18:1;;;10451:52;10520:18;;52674:64:0::1;10372:172:1::0;52674:64:0::1;52753:11;:26:::0;52592:195::o;40214:411::-;40296:18;;40262:7;;;40471:123;40487:29;:20;:27;:29::i;:::-;40485:1;:31;40471:123;;;40545:9;:37;40555:26;:20;40579:1;40555:23;:26::i;:::-;-1:-1:-1;;;;;40545:37:0;;;;;;;;;;;;-1:-1:-1;40545:37:0;;40537:45;;;;:::i;:::-;;-1:-1:-1;40518:3:0;;;;:::i;:::-;;;;40471:123;;;-1:-1:-1;40611:6:0;40214:411;-1:-1:-1;40214:411:0:o;49487:273::-;-1:-1:-1;;;;;49607:24:0;;49572:7;49607:24;;;:8;:24;;;;;;49654:15;49644:25;;49641:71;;-1:-1:-1;49700:1:0;;49487:273;-1:-1:-1;;49487:273:0:o;56672:1219::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;56832:20:::1;;56813:15;:39;;56805:68;;;;-1:-1:-1::0;;;56805:68:0::1;;;;;;;:::i;:::-;56905:40;29153:4;56905:15;:40;:::i;:::-;56884:20;:61:::0;57001:22:::1;::::0;57052:39:::1;::::0;-1:-1:-1;;;57052:39:0;;57085:4:::1;57052:39;::::0;::::1;4972:51:1::0;57001:22:0;;;::::1;-1:-1:-1::0;;;;;57001:22:0::1;::::0;56956:28:::1;::::0;57001:22;;57052:24:::1;::::0;4945:18:1;;57052:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57135:14;::::0;57104:54:::1;::::0;-1:-1:-1;;;57104:54:0;;-1:-1:-1;;;;;57135:14:0;;::::1;57104:54;::::0;::::1;5208:51:1::0;5275:18;;;5268:34;;;57035:56:0;;-1:-1:-1;57104:22:0;::::1;::::0;::::1;::::0;5181:18:1;;57104:54:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;57435:14:0::1;::::0;:216:::1;::::0;-1:-1:-1;;;57435:216:0;;57403:21:::1;::::0;-1:-1:-1;;;;;57435:14:0::1;::::0;:62:::1;::::0;:216:::1;::::0;57520:4:::1;::::0;57540:6;;57375:25:::1;::::0;;;57520:4;;57621:15:::1;::::0;57435:216:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;57662:21:0::1;57686:39;57708:17:::0;57686:21:::1;:39;:::i;:::-;57662:63;;57739:12;57736:146;;;57767:31;57784:13;57767:16;:31::i;:::-;57736:146;;;57857:13;57839:16;;:31;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;57736:146:0::1;9039:1;;;;56672:1219:::0;:::o;57977:309::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;58065:20:::1;;58046:15;:39;;58038:68;;;;-1:-1:-1::0;;;58038:68:0::1;;;;;;;:::i;:::-;58138:40;29153:4;58138:15;:40;:::i;:::-;58117:20;:61:::0;58203:10:::1;::::0;:51:::1;::::0;58190:9:::1;::::0;-1:-1:-1;;;;;58203:10:0::1;::::0;58227:21:::1;::::0;58190:9;58203:51;58190:9;58203:51;58227:21;58203:10;:51:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58189:65;;;58273:4;58265:13;;;::::0;::::1;9694:236:::0;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;9775:22:0;::::1;9767:73;;;::::0;-1:-1:-1;;;9767:73:0;;8890:2:1;9767:73:0::1;::::0;::::1;8872:21:1::0;8929:2;8909:18;;;8902:30;8968:34;8948:18;;;8941:62;-1:-1:-1;;;9019:18:1;;;9012:36;9065:19;;9767:73:0::1;8862:228:1::0;9767:73:0::1;9877:6;::::0;;9856:38:::1;::::0;-1:-1:-1;;;;;9856:38:0;;::::1;::::0;9877:6;::::1;::::0;9856:38:::1;::::0;::::1;9905:6;:17:::0;;-1:-1:-1;;;;;;9905:17:0::1;-1:-1:-1::0;;;;;9905:17:0;;;::::1;::::0;;;::::1;::::0;;9694:236::o;50810:249::-;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;50891:16:::1;::::0;;50876:14:::1;50918:18:::0;;;50955:10:::1;::::0;-1:-1:-1;;;;;50955:10:0::1;50947:47;50990:3;50977:9;50891:16:::0;50984:2:::1;50977:9;:::i;53845:81::-:0;8981:10;8970:7;8796;8823:6;-1:-1:-1;;;;;8823:6:0;;8758:79;8970:7;-1:-1:-1;;;;;8970:21:0;;8962:66;;;;-1:-1:-1;;;8962:66:0;;;;;;;:::i;:::-;53898:20:::1;:18;:20::i;:::-;53845:81::o:0;24445:152::-;24515:4;24539:50;24544:3;-1:-1:-1;;;;;24564:23:0;;24539:4;:50::i;59866:299::-;-1:-1:-1;;;;;59959:19:0;;59951:49;;;;-1:-1:-1;;;59951:49:0;;9709:2:1;59951:49:0;;;9691:21:1;9748:2;9728:18;;;9721:30;-1:-1:-1;;;9767:18:1;;;9760:47;9824:18;;59951:49:0;9681:167:1;59951:49:0;-1:-1:-1;;;;;60019:21:0;;60011:49;;;;-1:-1:-1;;;60011:49:0;;12196:2:1;60011:49:0;;;12178:21:1;12235:2;12215:18;;;12208:30;-1:-1:-1;;;12254:18:1;;;12247:45;12309:18;;60011:49:0;12168:165:1;60011:49:0;-1:-1:-1;;;;;60073:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;60125:32;;15930:25:1;;;60125:32:0;;15903:18:1;60125:32:0;;;;;;;59866:299;;;:::o;32240:1520::-;-1:-1:-1;;;;;32336:20:0;;32328:51;;;;-1:-1:-1;;;32328:51:0;;7845:2:1;32328:51:0;;;7827:21:1;7884:2;7864:18;;;7857:30;-1:-1:-1;;;7903:18:1;;;7896:48;7961:18;;32328:51:0;7817:168:1;32328:51:0;-1:-1:-1;;;;;32398:23:0;;32390:52;;;;-1:-1:-1;;;32390:52:0;;10055:2:1;32390:52:0;;;10037:21:1;10094:2;10074:18;;;10067:30;-1:-1:-1;;;10113:18:1;;;10106:46;10169:18;;32390:52:0;10027:166:1;32390:52:0;32535:15;32554:26;:9;32573:6;32554:18;:26::i;:::-;:59;;;-1:-1:-1;32584:29:0;:9;32603;32584:18;:29::i;:::-;32535:79;-1:-1:-1;32713:23:0;-1:-1:-1;;;;;32738:21:0;;32754:4;32738:21;;:49;;-1:-1:-1;;;;;;32763:24:0;;32782:4;32763:24;32738:49;32920:14;;32985:19;;32713:75;;-1:-1:-1;;;;;;32920:14:0;;;;32890:21;;32975:29;;;-1:-1:-1;;;32985:19:0;;;;32975:29;:59;;;;;33021:13;-1:-1:-1;;;;;33008:26:0;:9;-1:-1:-1;;;;;33008:26:0;;32975:59;32974:136;;;-1:-1:-1;33063:19:0;;-1:-1:-1;;;;;33050:32:0;;;-1:-1:-1;;;33063:19:0;;;;33050:32;:59;;;;;33096:13;-1:-1:-1;;;;;33086:23:0;:6;-1:-1:-1;;;;;33086:23:0;;33050:59;33232:19;;32946:165;;-1:-1:-1;33213:10:0;;-1:-1:-1;;;;;33224:27:0;;;-1:-1:-1;;;33232:19:0;;;;33224:27;;:53;;;33264:13;-1:-1:-1;;;;;33254:23:0;:6;-1:-1:-1;;;;;33254:23:0;;33224:53;33311:19;;33213:64;;-1:-1:-1;33288:11:0;;-1:-1:-1;;;;;33300:30:0;;;-1:-1:-1;;;33311:19:0;;;;33300:30;;:59;;;33346:13;-1:-1:-1;;;;;33333:26:0;:9;-1:-1:-1;;;;;33333:26:0;;33300:59;33288:71;;33400:18;:41;;;;33422:19;33400:41;:55;;;;33445:10;33400:55;33397:356;;;33471:43;33488:6;33496:9;33507:6;33471:16;:43::i;:::-;33397:356;;;33633:14;;;;;;;33625:49;;;;-1:-1:-1;;;33625:49:0;;13310:2:1;33625:49:0;;;13292:21:1;13349:2;13329:18;;;13322:30;13388:25;13368:18;;;13361:53;13431:18;;33625:49:0;13282:173:1;33625:49:0;33689:52;33704:6;33711:9;33721:6;33728:5;33734:6;33689:14;:52::i;:::-;32240:1520;;;;;;;;;:::o;55841:230::-;55997:20;;55983:13;:34;55975:43;;;;;;56029:20;:34;55841:230::o;42251:427::-;-1:-1:-1;;;;;42372:17:0;;42314:7;42372:17;;;:9;:17;;;;;;42355:14;;42314:7;;42355:34;;;:::i;:::-;-1:-1:-1;;;;;42552:25:0;;;;;;:17;:25;;;;;;42334:55;;-1:-1:-1;42541:36:0;;42538:49;;;-1:-1:-1;42586:1:0;;42251:427;-1:-1:-1;;42251:427:0:o;42538:49::-;-1:-1:-1;;;;;42619:25:0;;;;;;:17;:25;;;;;;-1:-1:-1;;;39100:5:0;42606:38;;:10;:38;:::i;:::-;42605:65;;;;:::i;25017:167::-;-1:-1:-1;;;;;25151:23:0;;25097:4;21826:19;;;:12;;;:19;;;;;;:24;;25121:55;21729:129;25270:117;25333:7;25360:19;25368:3;22027:18;;21944:109;25731:158;25805:7;25856:22;25860:3;25872:5;25856:3;:22::i;42748:758::-;42883:14;;42845:22;;42901:3;;42871:26;;42883:14;;42871:9;:26;:::i;:::-;42870:34;;;;:::i;:::-;42845:59;-1:-1:-1;42915:14:0;42932:26;42845:59;42932:9;:26;:::i;:::-;42915:43;;42988:14;42970:16;;:32;;;;;;;:::i;:::-;;;;-1:-1:-1;;43026:10:0;;43022:477;;43075:6;43053:18;;:28;;;;;;;:::i;:::-;;;;-1:-1:-1;43096:19:0;;-1:-1:-1;43116:17:0;:15;:17::i;:::-;43096:37;-1:-1:-1;43227:16:0;43223:265;;43284:6;43264:16;;:26;;;;;;;:::i;:::-;;;;-1:-1:-1;43223:265:0;;-1:-1:-1;43223:265:0;;43460:11;43425:31;-1:-1:-1;;;43425:6:0;:31;:::i;:::-;43424:47;;;;:::i;:::-;43405:14;;:67;;;;;;;:::i;:::-;;;;-1:-1:-1;;43223:265:0;43022:477;42748:758;;;:::o;45421:1633::-;45169:27;:34;;-1:-1:-1;;45169:34:0;45199:4;45169:34;;;;;;45523:4:::1;45169:27:::0;45505:24;;;::::1;::::0;;;;;;;;45570:11:::1;::::0;45505:24;;45169:27;45556:25:::1;::::0;-1:-1:-1;;;45570:11:0;::::1;45169:34:::0;45570:11;;::::1;::::0;45556:13;;::::1;;:25;:::i;:::-;45540:41;;::::0;-1:-1:-1;45592:19:0::1;45625:13;28308:1;45625:2;:13;:::i;:::-;45614:24;::::0;:8:::1;:24;:::i;:::-;45592:46;;45765:11;45749:15;:27;:40;;;-1:-1:-1::0;45778:11:0::1;::::0;::::1;::::0;45749:40:::1;45746:77;;;45805:7;;;;;45746:77;45943:13;::::0;45904:25:::1;::::0;45930:36:::1;::::0;::::1;::::0;45931:25:::1;::::0;45943:13;;::::1;;;45931:11:::0;:25:::1;:::i;:::-;45930:36;;;;:::i;:::-;45904:62:::0;-1:-1:-1;45977:25:0::1;46004:29;45904:62:::0;46004:11;:29:::1;:::i;:::-;45977:56:::0;-1:-1:-1;46094:16:0::1;46111:19;46129:1;46111:17:::0;:19:::1;:::i;:::-;46094:36:::0;-1:-1:-1;46141:19:0::1;46161:26;46094:36:::0;46161:17;:26:::1;:::i;:::-;46141:46:::0;-1:-1:-1;46270:17:0::1;46288:29;46300:17:::0;46141:46;46288:29:::1;:::i;:::-;46270:47:::0;-1:-1:-1;46432:21:0::1;46464:27;46270:47:::0;46464:16:::1;:27::i;:::-;46502:14;46518:41;46542:17:::0;46518:21:::1;:41;:::i;:::-;46502:58:::0;-1:-1:-1;46660:14:0::1;46698:9:::0;46678:18:::1;46685:11:::0;46502:58;46678:18:::1;:::i;:::-;46677:30;;;;:::i;:::-;46660:47;;46718:31;46732:8;46742:6;46718:13;:31::i;:::-;46872:21;46895:41;46919:17:::0;46895:21:::1;:41;:::i;:::-;46872:65;;47015:31;47032:13;47015:16;:31::i;:::-;45214:1;;;;;;;;;;;;;45226:27:::0;:35;;-1:-1:-1;;45226:35:0;;;45421:1633::o;19500:414::-;19563:4;21826:19;;;:12;;;:19;;;;;;19580:327;;-1:-1:-1;19623:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;19806:18;;19784:19;;;:12;;;:19;;;;;;:40;;;;19839:11;;19580:327;-1:-1:-1;19890:5:0;19883:12;;37796:440;-1:-1:-1;;;;;37915:17:0;;37891:21;37915:17;;;:9;:17;;;;;;37951:23;;;;37943:60;;;;-1:-1:-1;;;37943:60:0;;8537:2:1;37943:60:0;;;8519:21:1;8576:2;8556:18;;;8549:30;-1:-1:-1;;;8595:18:1;;;8588:54;8659:18;;37943:60:0;8509:174:1;37943:60:0;38059:27;38072:6;38079;38059:12;:27::i;:::-;38139:28;38149:9;38160:6;38139:9;:28::i;:::-;38209:9;-1:-1:-1;;;;;38193:33:0;38202:6;-1:-1:-1;;;;;38193:33:0;;38219:6;38193:33;;;;15930:25:1;;15918:2;15903:18;;15885:76;38193:33:0;;;;;;;;37796:440;;;;:::o;33861:3873::-;-1:-1:-1;;;;;34004:20:0;;;33977:24;34004:20;;;:9;:20;;;;;;;34059:17;;;;;;;;34095:23;;;;34087:60;;;;-1:-1:-1;;;34087:60:0;;8537:2:1;34087:60:0;;;8519:21:1;8576:2;8556:18;;;8549:30;-1:-1:-1;;;8595:18:1;;;8588:54;8659:18;;34087:60:0;8509:174:1;34087:60:0;34160:9;34183:6;34180:2232;;;34209:38;:21;34240:6;34209:30;:38::i;:::-;34205:427;;-1:-1:-1;;;;;34397:17:0;;;;;;:9;:17;;;;;;34416:15;-1:-1:-1;34397:34:0;;:52;;-1:-1:-1;34433:16:0;;;;;;;34397:52;34389:82;;;;-1:-1:-1;;;34389:82:0;;15446:2:1;34389:82:0;;;15428:21:1;15485:2;15465:18;;;15458:30;-1:-1:-1;;;15504:18:1;;;15497:48;15562:18;;34389:82:0;15418:168:1;34389:82:0;34604:12;;34588:28;;:15;:28;:::i;:::-;-1:-1:-1;;;;;34570:17:0;;;;;;:9;:17;;;;;:46;34205:427;34773:9;;34765:6;:17;;34757:44;;;;-1:-1:-1;;;34757:44:0;;11100:2:1;34757:44:0;;;11082:21:1;11139:2;11119:18;;;11112:30;-1:-1:-1;;;11158:18:1;;;11151:45;11213:18;;34757:44:0;11072:165:1;34757:44:0;-1:-1:-1;34820:8:0;;;;;;;34180:2232;;;34853:5;34850:1562;;;34869:40;:20;34899:9;34869:29;:40::i;:::-;34865:427;;-1:-1:-1;;;;;35058:19:0;;;;;;:8;:19;;;;;;35079:15;-1:-1:-1;35058:36:0;;:53;;-1:-1:-1;35096:15:0;;;;35058:53;35050:81;;;;-1:-1:-1;;;35050:81:0;;11444:2:1;35050:81:0;;;11426:21:1;11483:2;11463:18;;;11456:30;-1:-1:-1;;;11502:18:1;;;11495:46;11558:18;;35050:81:0;11416:166:1;35050:81:0;35265:11;;35249:27;;:15;:27;:::i;:::-;-1:-1:-1;;;;;35229:19:0;;;;;;:8;:19;;;;;:47;34865:427;35430:12;;35405:23;35422:6;35405:16;:23;:::i;:::-;:37;;35397:65;;;;-1:-1:-1;;;35397:65:0;;13662:2:1;35397:65:0;;;13644:21:1;13701:2;13681:18;;;13674:30;-1:-1:-1;;;13720:18:1;;;13713:46;13776:18;;35397:65:0;13634:166:1;35397:65:0;35486:9;;35476:6;:19;;35468:65;;;;-1:-1:-1;;;35468:65:0;;14350:2:1;35468:65:0;;;14332:21:1;14389:2;14369:18;;;14362:30;14428:34;14408:18;;;14401:62;-1:-1:-1;;;14479:18:1;;;14472:32;14521:19;;35468:65:0;14322:224:1;35468:65:0;-1:-1:-1;35552:7:0;;;;34850:1562;;;35799:15;28308:1;35799:2;:15;:::i;:::-;35791:6;:23;35788:41;;35816:13;35822:6;35816:5;:13::i;:::-;35968:12;;35943:23;35960:6;35943:16;:23;:::i;:::-;:37;;35935:65;;;;-1:-1:-1;;;35935:65:0;;13662:2:1;35935:65:0;;;13644:21:1;13701:2;13681:18;;;13674:30;-1:-1:-1;;;13720:18:1;;;13713:46;13776:18;;35935:65:0;13634:166:1;35935:65:0;36232:38;:21;36263:6;36232:30;:38::i;:::-;36228:139;;-1:-1:-1;;;;;36297:17:0;;;;;;:9;:17;;;;;;36316:15;-1:-1:-1;36297:34:0;;:52;;-1:-1:-1;36333:16:0;;;;;;;36297:52;36289:78;;;;-1:-1:-1;;;36289:78:0;;14007:2:1;36289:78:0;;;13989:21:1;14046:2;14026:18;;;14019:30;-1:-1:-1;;;14065:18:1;;;14058:44;14119:18;;36289:78:0;13979:164:1;36289:78:0;-1:-1:-1;36386:12:0;;;;;;;34850:1562;36747:19;;-1:-1:-1;;;;;36739:27:0;;;-1:-1:-1;;;36747:19:0;;;;36739:27;;;;36738:50;;-1:-1:-1;36771:16:0;;;;36770:17;36738:50;:82;;;;-1:-1:-1;36792:27:0;;;;36791:28;36738:82;:90;;;;;36822:6;36738:90;36735:128;;;36843:20;:18;:20::i;:::-;36932:23;36956:36;36970:6;36978:3;36983:8;;;;;;;;;;;36956:13;:36::i;:::-;37161:13;;36932:60;;-1:-1:-1;37100:21:0;;37122:53;;37136:6;;37144:3;;37149:25;;37161:13;;;;;;;-1:-1:-1;;;37149:11:0;;;:25;:::i;:::-;37122:13;:53::i;:::-;37100:75;-1:-1:-1;37239:19:0;37267:31;37100:75;37267:15;:31;:::i;:::-;37259:40;;:6;:40;:::i;:::-;37239:60;;37357:27;37370:6;37377;37357:12;:27::i;:::-;37479:4;37461:24;;;;:9;:24;;;;;:41;;37489:13;;37461:24;:41;;37489:13;;37461:41;:::i;:::-;;;;;;;;37557:15;37537:18;;:35;;;;;;;:::i;:::-;;;;-1:-1:-1;37627:33:0;;-1:-1:-1;37637:9:0;37648:11;37627:9;:33::i;:::-;37702:9;-1:-1:-1;;;;;37686:38:0;37695:6;-1:-1:-1;;;;;37686:38:0;;37712:11;37686:38;;;;15930:25:1;;15918:2;15903:18;;15885:76;37686:38:0;;;;;;;;33861:3873;;;;;;;;;;;:::o;22397:204::-;22492:18;;22464:7;;22492:26;-1:-1:-1;22484:73:0;;;;-1:-1:-1;;;22484:73:0;;7442:2:1;22484:73:0;;;7424:21:1;7481:2;7461:18;;;7454:30;7520:34;7500:18;;;7493:62;-1:-1:-1;;;7571:18:1;;;7564:32;7613:19;;22484:73:0;7414:224:1;22484:73:0;22575:3;:11;;22587:5;22575:18;;;;;;-1:-1:-1;;;22575:18:0;;;;;;;;;;;;;;;;;22568:25;;22397:204;;;;:::o;47104:455::-;47197:14;;47165:56;;47182:4;;-1:-1:-1;;;;;47197:14:0;47214:6;47165:8;:56::i;:::-;47256:16;;;47270:1;47256:16;;;;;;;;47232:21;;47256:16;;;;;;;;;;-1:-1:-1;47256:16:0;47232:40;;47301:4;47283;47288:1;47283:7;;;;;;-1:-1:-1;;;47283:7:0;;;;;;;;;-1:-1:-1;;;;;47283:23:0;;;:7;;;;;;;;;;:23;;;;47327:14;;:21;;;-1:-1:-1;;;47327:21:0;;;;:14;;;;;:19;;:21;;;;;47283:7;;47327:21;;;;;:14;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47317:4;47322:1;47317:7;;;;;;-1:-1:-1;;;47317:7:0;;;;;;;;;-1:-1:-1;;;;;47317:31:0;;;:7;;;;;;;;;:31;47361:14;;:190;;-1:-1:-1;;;47361:190:0;;:14;;;:65;;:190;;47441:6;;47361:14;;47478:4;;47505;;47525:15;;47361:190;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47104:455;;:::o;47686:397::-;47780:9;47768:10;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;;47832:14:0;;47800:61;;47817:4;;-1:-1:-1;;;;;47832:14:0;47849:11;47800:8;:61::i;:::-;47872:14;;:203;;-1:-1:-1;;;47872:203:0;;-1:-1:-1;;;;;47872:14:0;;;;:30;;47910:9;;47872:203;;47943:4;;47963:11;;47872:14;;;;47943:4;;48049:15;;47872:203;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;41457:648::-;-1:-1:-1;;;;;41592:15:0;;41574:17;41592:15;;;:9;:15;;;;;;:22;;41608:6;;41592:22;:::i;:::-;41574:40;;41638:27;41660:4;41638:21;:27::i;:::-;41635:102;;;-1:-1:-1;;;;;41680:15:0;;;;;;;:9;:15;;;;;:25;;;;-1:-1:-1;41457:648:0:o;41635:102::-;41802:15;41818:21;41834:4;41818:15;:21::i;:::-;-1:-1:-1;;;;;41877:15:0;;;;;;:9;:15;;;;;:25;;;41986:14;;41802:37;;-1:-1:-1;41986:26:0;;41893:9;;41986:26;:::i;:::-;-1:-1:-1;;;;;41960:23:0;;;;;;:17;:23;;;;;;;;:52;;;;42073:8;:14;;;;;:23;;42089:7;;41960:23;42073;;42089:7;;42073:23;:::i;40720:645::-;-1:-1:-1;;;;;40852:15:0;;40834:17;40852:15;;;:9;:15;;;;;;:22;;40868:6;;40852:22;:::i;:::-;40834:40;;40898:27;40920:4;40898:21;:27::i;:::-;40895:102;;;-1:-1:-1;;;;;40940:15:0;;;;;;;:9;:15;;;;;:25;;;;-1:-1:-1;40720:645:0:o;40895:102::-;41062:15;41078:21;41094:4;41078:15;:21::i;:::-;41062:37;;41200:9;41183:14;;:26;;;;:::i;:::-;-1:-1:-1;;;;;41157:23:0;;;;;;:17;:23;;;;;;;;:52;;;;41270:8;:14;;;;;:23;;41286:7;;41157:23;41270;;41286:7;;41270:23;:::i;:::-;;;;-1:-1:-1;;;;;;;;41332:15:0;;;;;;;:9;:15;;;;;:25;;;;-1:-1:-1;40720:645:0:o;43621:1219::-;43677:14;;-1:-1:-1;;;43677:14:0;;;;43676:15;43668:24;;;;;;43703:14;:19;;-1:-1:-1;;;;43703:19:0;-1:-1:-1;;;43703:19:0;;;;43761:27;43783:4;43761:21;:27::i;:::-;43758:495;;;-1:-1:-1;;;;;;43875:14:0;;;;;;:8;:14;;;;;;;43904:16;;;43758:495;;;43961:17;43979:21;43995:4;43979:15;:21::i;:::-;-1:-1:-1;;;;;44111:15:0;;;;;;:9;:15;;;;;;44094:14;;43961:39;;-1:-1:-1;44094:32:0;;;:::i;:::-;-1:-1:-1;;;;;44068:23:0;;;;;;:17;:23;;;;;;;;:58;;;;44186:8;:14;;;;:24;;44201:9;;44186:24;:::i;:::-;-1:-1:-1;;;;;44225:14:0;;44240:1;44225:14;;;:8;:14;;;;;:16;44179:31;-1:-1:-1;;43758:495:0;44266:9;44263:106;;-1:-1:-1;;44316:14:0;:20;;-1:-1:-1;;;;44316:20:0;;;43621:1219::o;44263:106::-;44393:6;44379:12;;:20;;;;;;;:::i;:::-;;;;-1:-1:-1;;44434:16:0;;;44448:1;44434:16;;;;;;;;44410:21;;44434:16;;;;;;;;-1:-1:-1;;44471:14:0;;:21;;;-1:-1:-1;;;44471:21:0;;;;44410:40;;-1:-1:-1;;;;;;44471:14:0;;;;:19;;-1:-1:-1;44471:21:0;;;;;;;;;;;;;;:14;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;44461:4;44466:1;44461:7;;;;;;-1:-1:-1;;;44461:7:0;;;;;;;;;;;;;;:31;-1:-1:-1;;;;;44461:31:0;;;-1:-1:-1;;;;;44461:31:0;;;;;44519:42;44509:4;44514:1;44509:7;;;;;;-1:-1:-1;;;44509:7:0;;;;;;;;;-1:-1:-1;;;;;44509:52:0;;;:7;;;;;;;;;:52;44599:14;;:149;;-1:-1:-1;;;44599:149:0;;:14;;;:65;;44672:6;;44599:149;;:14;;44702:4;;44717;;44732:15;;44599:149;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;44774:27:0;;;16140:25:1;;;-1:-1:-1;;;;;16201:32:1;;16196:2;16181:18;;16174:60;44774:27:0;;-1:-1:-1;16113:18:1;;-1:-1:-1;44774:27:0;;-1:-1:-1;16095:145:1;44774:27:0;;;;;;;;-1:-1:-1;;44812:14:0;:20;;-1:-1:-1;;;;44812:20:0;;;-1:-1:-1;43621:1219:0:o;38291:156::-;38381:7;38434:5;38420:10;38409:21;;38416:3;38409:10;;:6;:10;;;;:::i;:::-;:21;;;;:::i;:::-;38408:31;;;;:::i;:::-;38401:38;38291:156;-1:-1:-1;;;;38291:156:0:o;14::1:-;80:20;;140:4;129:16;;119:27;;109:2;;160:1;157;150:12;109:2;61:109;;;:::o;175:257::-;234:6;287:2;275:9;266:7;262:23;258:32;255:2;;;308:6;300;293:22;255:2;352:9;339:23;371:31;396:5;371:31;:::i;437:261::-;507:6;560:2;548:9;539:7;535:23;531:32;528:2;;;581:6;573;566:22;528:2;618:9;612:16;637:31;662:5;637:31;:::i;703:398::-;771:6;779;832:2;820:9;811:7;807:23;803:32;800:2;;;853:6;845;838:22;800:2;897:9;884:23;916:31;941:5;916:31;:::i;:::-;966:5;-1:-1:-1;1023:2:1;1008:18;;995:32;1036:33;995:32;1036:33;:::i;:::-;1088:7;1078:17;;;790:311;;;;;:::o;1106:466::-;1183:6;1191;1199;1252:2;1240:9;1231:7;1227:23;1223:32;1220:2;;;1273:6;1265;1258:22;1220:2;1317:9;1304:23;1336:31;1361:5;1336:31;:::i;:::-;1386:5;-1:-1:-1;1443:2:1;1428:18;;1415:32;1456:33;1415:32;1456:33;:::i;:::-;1210:362;;1508:7;;-1:-1:-1;;;1562:2:1;1547:18;;;;1534:32;;1210:362::o;1577:325::-;1645:6;1653;1706:2;1694:9;1685:7;1681:23;1677:32;1674:2;;;1727:6;1719;1712:22;1674:2;1771:9;1758:23;1790:31;1815:5;1790:31;:::i;:::-;1840:5;1892:2;1877:18;;;;1864:32;;-1:-1:-1;;;1664:238:1:o;1907:251::-;1963:6;2016:2;2004:9;1995:7;1991:23;1987:32;1984:2;;;2037:6;2029;2022:22;1984:2;2081:9;2068:23;2100:28;2122:5;2100:28;:::i;2163:255::-;2230:6;2283:2;2271:9;2262:7;2258:23;2254:32;2251:2;;;2304:6;2296;2289:22;2251:2;2341:9;2335:16;2360:28;2382:5;2360:28;:::i;2423:190::-;2482:6;2535:2;2523:9;2514:7;2510:23;2506:32;2503:2;;;2556:6;2548;2541:22;2503:2;-1:-1:-1;2584:23:1;;2493:120;-1:-1:-1;2493:120:1:o;2618:194::-;2688:6;2741:2;2729:9;2720:7;2716:23;2712:32;2709:2;;;2762:6;2754;2747:22;2709:2;-1:-1:-1;2790:16:1;;2699:113;-1:-1:-1;2699:113:1:o;2817:258::-;2885:6;2893;2946:2;2934:9;2925:7;2921:23;2917:32;2914:2;;;2967:6;2959;2952:22;2914:2;-1:-1:-1;;2995:23:1;;;3065:2;3050:18;;;3037:32;;-1:-1:-1;2904:171:1:o;3080:316::-;3168:6;3176;3184;3237:2;3225:9;3216:7;3212:23;3208:32;3205:2;;;3258:6;3250;3243:22;3205:2;3292:9;3286:16;3276:26;;3342:2;3331:9;3327:18;3321:25;3311:35;;3386:2;3375:9;3371:18;3365:25;3355:35;;3195:201;;;;;:::o;3401:192::-;3458:6;3511:2;3499:9;3490:7;3486:23;3482:32;3479:2;;;3532:6;3524;3517:22;3479:2;3560:27;3577:9;3560:27;:::i;3598:545::-;3690:6;3698;3706;3714;3722;3730;3783:3;3771:9;3762:7;3758:23;3754:33;3751:2;;;3805:6;3797;3790:22;3751:2;3833:27;3850:9;3833:27;:::i;:::-;3823:37;;3879:36;3911:2;3900:9;3896:18;3879:36;:::i;:::-;3869:46;;3934:36;3966:2;3955:9;3951:18;3934:36;:::i;:::-;3924:46;;3989:36;4021:2;4010:9;4006:18;3989:36;:::i;:::-;3979:46;;4044:37;4076:3;4065:9;4061:19;4044:37;:::i;:::-;4034:47;;4100:37;4132:3;4121:9;4117:19;4100:37;:::i;:::-;4090:47;;3741:402;;;;;;;;:::o;4148:463::-;4201:3;4239:5;4233:12;4266:6;4261:3;4254:19;4292:4;4321:2;4316:3;4312:12;4305:19;;4358:2;4351:5;4347:14;4379:3;4391:195;4405:6;4402:1;4399:13;4391:195;;;4470:13;;-1:-1:-1;;;;;4466:39:1;4454:52;;4526:12;;;;4561:15;;;;4502:1;4420:9;4391:195;;;-1:-1:-1;4602:3:1;;4209:402;-1:-1:-1;;;;;4209:402:1:o;5313:607::-;-1:-1:-1;;;;;5672:15:1;;;5654:34;;5719:2;5704:18;;5697:34;;;;5762:2;5747:18;;5740:34;;;;5805:2;5790:18;;5783:34;;;;5854:15;;;5848:3;5833:19;;5826:44;5634:3;5886:19;;5879:35;;;;5603:3;5588:19;;5570:350::o;6117:510::-;6388:6;6377:9;6370:25;6431:3;6426:2;6415:9;6411:18;6404:31;6351:4;6452:57;6504:3;6493:9;6489:19;6481:6;6452:57;:::i;:::-;-1:-1:-1;;;;;6545:32:1;;;;6540:2;6525:18;;6518:60;-1:-1:-1;6609:2:1;6594:18;6587:34;6444:65;6360:267;-1:-1:-1;;6360:267:1:o;6632:603::-;6744:4;6773:2;6802;6791:9;6784:21;6834:6;6828:13;6877:6;6872:2;6861:9;6857:18;6850:34;6902:4;6915:140;6929:6;6926:1;6923:13;6915:140;;;7024:14;;;7020:23;;7014:30;6990:17;;;7009:2;6986:26;6979:66;6944:10;;6915:140;;;7073:6;7070:1;7067:13;7064:2;;;7143:4;7138:2;7129:6;7118:9;7114:22;7110:31;7103:45;7064:2;-1:-1:-1;7219:2:1;7198:15;-1:-1:-1;;7194:29:1;7179:45;;;;7226:2;7175:54;;6753:482;-1:-1:-1;;;6753:482:1:o;7990:340::-;8192:2;8174:21;;;8231:2;8211:18;;;8204:30;-1:-1:-1;;;8265:2:1;8250:18;;8243:46;8321:2;8306:18;;8164:166::o;12747:356::-;12949:2;12931:21;;;12968:18;;;12961:30;13027:34;13022:2;13007:18;;13000:62;13094:2;13079:18;;12921:182::o;16245:582::-;16544:6;16533:9;16526:25;16587:6;16582:2;16571:9;16567:18;16560:34;16630:3;16625:2;16614:9;16610:18;16603:31;16507:4;16651:57;16703:3;16692:9;16688:19;16680:6;16651:57;:::i;:::-;-1:-1:-1;;;;;16744:32:1;;;;16739:2;16724:18;;16717:60;-1:-1:-1;16808:3:1;16793:19;16786:35;16643:65;16516:311;-1:-1:-1;;;16516:311:1:o;17814:128::-;17854:3;17885:1;17881:6;17878:1;17875:13;17872:2;;;17891:18;;:::i;:::-;-1:-1:-1;17927:9:1;;17862:80::o;17947:204::-;17985:3;18021:4;18018:1;18014:12;18053:4;18050:1;18046:12;18088:3;18082:4;18078:14;18073:3;18070:23;18067:2;;;18096:18;;:::i;:::-;18132:13;;17993:158;-1:-1:-1;;;17993:158:1:o;18156:217::-;18196:1;18222;18212:2;;-1:-1:-1;;;18247:31:1;;18301:4;18298:1;18291:15;18329:4;18254:1;18319:15;18212:2;-1:-1:-1;18358:9:1;;18202:171::o;18378:422::-;18467:1;18510:5;18467:1;18524:270;18545:7;18535:8;18532:21;18524:270;;;18604:4;18600:1;18596:6;18592:17;18586:4;18583:27;18580:2;;;18613:18;;:::i;:::-;18663:7;18653:8;18649:22;18646:2;;;18683:16;;;;18646:2;18762:22;;;;18722:15;;;;18524:270;;;18528:3;18442:358;;;;;:::o;18805:140::-;18863:5;18892:47;18933:4;18923:8;18919:19;18913:4;18999:5;19029:8;19019:2;;-1:-1:-1;19070:1:1;19084:5;;19019:2;19118:4;19108:2;;-1:-1:-1;19155:1:1;19169:5;;19108:2;19200:4;19218:1;19213:59;;;;19286:1;19281:130;;;;19193:218;;19213:59;19243:1;19234:10;;19257:5;;;19281:130;19318:3;19308:8;19305:17;19302:2;;;19325:18;;:::i;:::-;-1:-1:-1;;19381:1:1;19367:16;;19396:5;;19193:218;;19495:2;19485:8;19482:16;19476:3;19470:4;19467:13;19463:36;19457:2;19447:8;19444:16;19439:2;19433:4;19430:12;19426:35;19423:77;19420:2;;;-1:-1:-1;19532:19:1;;;19564:5;;19420:2;19611:34;19636:8;19630:4;19611:34;:::i;:::-;19681:6;19677:1;19673:6;19669:19;19660:7;19657:32;19654:2;;;19692:18;;:::i;:::-;19730:20;;19009:747;-1:-1:-1;;;19009:747:1:o;19761:168::-;19801:7;19867:1;19863;19859:6;19855:14;19852:1;19849:21;19844:1;19837:9;19830:17;19826:45;19823:2;;;19874:18;;:::i;:::-;-1:-1:-1;19914:9:1;;19813:116::o;19934:125::-;19974:4;20002:1;19999;19996:8;19993:2;;;20007:18;;:::i;:::-;-1:-1:-1;20044:9:1;;19983:76::o;20064:135::-;20103:3;-1:-1:-1;;20124:17:1;;20121:2;;;20144:18;;:::i;:::-;-1:-1:-1;20191:1:1;20180:13;;20111:88::o;20204:127::-;20265:10;20260:3;20256:20;20253:1;20246:31;20296:4;20293:1;20286:15;20320:4;20317:1;20310:15;20336:131;-1:-1:-1;;;;;20411:31:1;;20401:42;;20391:2;;20457:1;20454;20447:12;20472:118;20558:5;20551:13;20544:21;20537:5;20534:32;20524:2;;20580:1;20577;20570:12

Swarm Source

ipfs://9c15062206dbfe4f5fecbf0990f0719e5a4baf1493adc9e323b6217881519223
Loading