Token Power

 

Overview ERC-20

Price
$0.00 @ 0.001929 FTM (+5.53%)
Fully Diluted Market Cap
Total Supply:
20,456,743 POWER

Holders:
7,091 addresses

Transfers:
-

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

OVERVIEW

Power Nodes from the console, view, manage, and launch POWER-Nodes.

Market

Volume (24H):$2.54
Market Capitalization:$0.00
Circulating Supply:0.00 POWER
Market Data Source: Coinmarketcap


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

Contract Source Code Verified (Exact Match)

Contract Name:
Power

Compiler Version
v0.8.7+commit.e28d00a7

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2021-12-11
*/

// SODX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

/**
 * @title SafeMathUint
 * @dev Math operations with safety TKNcks that revert on error
 */
library SafeMathUint {
    function toInt256Safe(uint256 a) internal pure returns (int256) {
        int256 b = int256(a);
        require(b >= 0, "toInt256Safe: B LESS THAN ZERO");
        return b;
    }
}

/**
 * @title SafeMathInt
 * @dev Math operations for int256 with overflow safety TKNcks.
 */
library SafeMathInt {
    int256 private constant MIN_INT256 = int256(1) << 255;
    int256 private constant MAX_INT256 = ~(int256(1) << 255);

    /**
     * @dev Multiplies two int256 variables and fails on overflow.
     */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a * b;

        // Detect overflow when multiplying MIN_INT256 with -1
        require(
            c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256),
            "mul: A B C combi values invalid with MIN_INT256"
        );
        require((b == 0) || (c / b == a), "mul: A B C combi values invalid");
        return c;
    }

    /**
     * @dev Division of two int256 variables and fails on overflow.
     */
    function div(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when dividing MIN_INT256 by -1
        require(b != -1 || a != MIN_INT256, "div: b == 1 OR A == MIN_INT256");

        // Solidity already throws when dividing by 0.
        return a / b;
    }

    /**
     * @dev Subtracts two int256 variables and fails on overflow.
     */
    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require(
            (b >= 0 && c <= a) || (b < 0 && c > a),
            "sub: A B C combi values invalid"
        );
        return c;
    }

    /**
     * @dev Adds two int256 variables and fails on overflow.
     */
    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require(
            (b >= 0 && c >= a) || (b < 0 && c < a),
            "add: A B C combi values invalid"
        );
        return c;
    }

    /**
     * @dev Converts to absolute value, and fails on overflow.
     */
    function abs(int256 a) internal pure returns (int256) {
        require(a != MIN_INT256, "abs: A EQUAL MIN INT256");
        return a < 0 ? -a : a;
    }

    function toUint256Safe(int256 a) internal pure returns (uint256) {
        require(a >= 0, "toUint256Safe: A LESS THAN ZERO");
        return uint256(a);
    }
}



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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

library IterableMapping {
    // Iterable mapping from address to uint;
    struct Map {
        address[] keys;
        mapping(address => uint256) values;
        mapping(address => uint256) indexOf;
        mapping(address => bool) inserted;
    }

    function get(Map storage map, address key) public view returns (uint256) {
        return map.values[key];
    }

    function getIndexOfKey(Map storage map, address key)
    public
    view
    returns (int256)
    {
        if (!map.inserted[key]) {
            return -1;
        }
        return int256(map.indexOf[key]);
    }

    function getKeyAtIndex(Map storage map, uint256 index)
    public
    view
    returns (address)
    {
        return map.keys[index];
    }

    function size(Map storage map) public view returns (uint256) {
        return map.keys.length;
    }

    function set(
        Map storage map,
        address key,
        uint256 val
    ) public {
        if (map.inserted[key]) {
            map.values[key] = val;
        } else {
            map.inserted[key] = true;
            map.values[key] = val;
            map.indexOf[key] = map.keys.length;
            map.keys.push(key);
        }
    }

    function remove(Map storage map, address key) public {
        if (!map.inserted[key]) {
            return;
        }

        delete map.inserted[key];
        delete map.values[key];

        uint256 index = map.indexOf[key];
        uint256 lastIndex = map.keys.length - 1;
        address lastKey = map.keys[lastIndex];

        map.indexOf[lastKey] = index;
        delete map.indexOf[key];

        map.keys[index] = lastKey;
        map.keys.pop();
    }
}

// OpenZeppelin Contracts v4.3.2 (utils/Address.sol)



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

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

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

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

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data)
    internal
    returns (bytes memory)
    {
        return functionCall(target, data, "Address: low-level call failed");
    }

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

interface IJoeRouter01 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
    external
    returns (
        uint256 amountA,
        uint256 amountB,
        uint256 liquidity
    );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
    external
    payable
    returns (
        uint256 amountToken,
        uint256 amountETH,
        uint256 liquidity
    );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETH(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETHWithPermit(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountToken, uint256 amountETH);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) external pure returns (uint256 amountB);

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountOut);

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountIn);

    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);
}


// pragma solidity >=0.6.2;

interface IJoeRouter02 is IJoeRouter01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountETH);

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}


interface IUniswapV2Pair {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 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 (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender)
    external
    view
    returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 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 (uint256);

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

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

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
    external
    view
    returns (
        uint112 reserve0,
        uint112 reserve1,
        uint32 blockTimestampLast
    );

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(address to)
    external
    returns (uint256 amount0, uint256 amount1);

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
}

interface IJoeFactory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint256);

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function migrator() external view returns (address);

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

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

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

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;

    function setMigrator(address) external;
}




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

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

contract Ownable is Context {
    address private _owner;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



contract ERC20 is Context, IERC20, IERC20Metadata {
    using SafeMath for uint256;

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(sender, recipient, amount);

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

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

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts v4.3.2 (token/ERC20/utils/SafeERC20.sol)



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

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

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

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

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

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

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

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

// OpenZeppelin Contracts v4.3.2 (finance/PaymentSplitter.sol)



/**
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 *
 * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
 * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
 * to run tests before sending real value to this contract.
 */
contract PaymentSplitter is Context {
    event PayeeAdded(address account, uint256 shares);
    event PaymentReleased(address to, uint256 amount);
    event ERC20PaymentReleased(
        IERC20 indexed token,
        address to,
        uint256 amount
    );
    event PaymentReceived(address from, uint256 amount);

    uint256 private _totalShares;
    uint256 private _totalReleased;

    mapping(address => uint256) private _shares;
    mapping(address => uint256) private _released;
    address[] private _payees;

    mapping(IERC20 => uint256) private _erc20TotalReleased;
    mapping(IERC20 => mapping(address => uint256)) private _erc20Released;

    /**
     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
     * the matching position in the `shares` array.
     *
     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
     * duplicates in `payees`.
     */
    constructor(address[] memory payees, uint256[] memory shares_) payable {
        require(
            payees.length == shares_.length,
            "PaymentSplitter: payees and shares length mismatch"
        );
        require(payees.length > 0, "PaymentSplitter: no payees");

        for (uint256 i = 0; i < payees.length; i++) {
            _addPayee(payees[i], shares_[i]);
        }
    }

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     */
    receive() external payable virtual {
        emit PaymentReceived(_msgSender(), msg.value);
    }

    /**
     * @dev Getter for the total shares held by payees.
     */
    function totalShares() public view returns (uint256) {
        return _totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    function totalReleased() public view returns (uint256) {
        return _totalReleased;
    }

    /**
     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
     * contract.
     */
    function totalReleased(IERC20 token) public view returns (uint256) {
        return _erc20TotalReleased[token];
    }

    /**
     * @dev Getter for the amount of shares held by an account.
     */
    function shares(address account) public view returns (uint256) {
        return _shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    function released(address account) public view returns (uint256) {
        return _released[account];
    }

    /**
     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
     * IERC20 contract.
     */
    function released(IERC20 token, address account)
    public
    view
    returns (uint256)
    {
        return _erc20Released[token][account];
    }

    /**
     * @dev Getter for the address of the payee number `index`.
     */
    function payee(uint256 index) public view returns (address) {
        return _payees[index];
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    function release(address payable account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = address(this).balance + totalReleased();
        uint256 payment = _pendingPayment(
            account,
            totalReceived,
            released(account)
        );

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _released[account] += payment;
        _totalReleased += payment;

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
     * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
     * contract.
     */
    function release(IERC20 token, address account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = token.balanceOf(address(this)) +
        totalReleased(token);
        uint256 payment = _pendingPayment(
            account,
            totalReceived,
            released(token, account)
        );

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _erc20Released[token][account] += payment;
        _erc20TotalReleased[token] += payment;

        SafeERC20.safeTransfer(token, account, payment);
        emit ERC20PaymentReleased(token, account, payment);
    }

    /**
     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and
     * already released amounts.
     */
    function _pendingPayment(
        address account,
        uint256 totalReceived,
        uint256 alreadyReleased
    ) private view returns (uint256) {
        return
        (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) private {
        require(
            account != address(0),
            "PaymentSplitter: account is the zero address"
        );
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(
            _shares[account] == 0,
            "PaymentSplitter: account already has shares"
        );

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }
}

contract NODERewardManagement {
    using SafeMath for uint256;
    using IterableMapping for IterableMapping.Map;

    struct NodeEntity {
        string name;
        uint256 creationTime;
        uint256 lastClaimTime;
        uint256 rewardAvailable;
    }

    IterableMapping.Map private nodeOwners;
    mapping(address => NodeEntity[]) private _nodesOfUser;

    uint256 public nodePrice;
    uint256 public rewardPerNode;
    uint256 public claimTime;

    address public gateKeeper;
    address public token;

    bool public autoDistri = true;
    bool public distribution = false;

    uint256 public gasForDistribution = 300000;
    uint256 public lastDistributionCount = 0;
    uint256 public lastIndexProcessed = 0;

    uint256 public totalNodesCreated = 0;
    uint256 public totalRewardStaked = 0;

    constructor(
        uint256 _nodePrice,
        uint256 _rewardPerNode,
        uint256 _claimTime
    ) {
        nodePrice = _nodePrice;
        rewardPerNode = _rewardPerNode;
        claimTime = _claimTime;
        gateKeeper = msg.sender;
    }

    modifier onlySentry() {
        require(msg.sender == token || msg.sender == gateKeeper, "Fuck off");
        _;
    }

    function setToken (address token_) external onlySentry {
        token = token_;
    }

    function distributeRewards(uint256 gas, uint256 rewardNode)
    private
    returns (
        uint256,
        uint256,
        uint256
    )
    {
        distribution = true;
        uint256 numberOfnodeOwners = nodeOwners.keys.length;
        require(numberOfnodeOwners > 0, "DISTRI REWARDS: NO NODE OWNERS");
        if (numberOfnodeOwners == 0) {
            return (0, 0, lastIndexProcessed);
        }

        uint256 gasUsed = 0;
        uint256 gasLeft = gasleft();
        uint256 newGasLeft;
        uint256 localLastIndex = lastIndexProcessed;
        uint256 iterations = 0;
        uint256 newClaimTime = block.timestamp;
        uint256 nodesCount;
        uint256 claims = 0;
        NodeEntity[] storage nodes;
        NodeEntity storage _node;

        while (gasUsed < gas && iterations < numberOfnodeOwners) {
            localLastIndex++;
            if (localLastIndex >= nodeOwners.keys.length) {
                localLastIndex = 0;
            }
            nodes = _nodesOfUser[nodeOwners.keys[localLastIndex]];
            nodesCount = nodes.length;
            for (uint256 i = 0; i < nodesCount; i++) {
                _node = nodes[i];
                if (claimable(_node)) {
                    _node.rewardAvailable += rewardNode;
                    _node.lastClaimTime = newClaimTime;
                    totalRewardStaked += rewardNode;
                    claims++;
                }
            }
            iterations++;

            newGasLeft = gasleft();

            if (gasLeft > newGasLeft) {
                gasUsed = gasUsed.add(gasLeft.sub(newGasLeft));
            }

            gasLeft = newGasLeft;
        }
        lastIndexProcessed = localLastIndex;
        distribution = false;
        return (iterations, claims, lastIndexProcessed);
    }

    function createNode(address account, string memory nodeName) external onlySentry {
        require(
            isNameAvailable(account, nodeName),
            "CREATE NODE: Name not available"
        );
        _nodesOfUser[account].push(
            NodeEntity({
        name: nodeName,
        creationTime: block.timestamp,
        lastClaimTime: block.timestamp,
        rewardAvailable: rewardPerNode
        })
        );
        nodeOwners.set(account, _nodesOfUser[account].length);
        totalNodesCreated++;
        if (autoDistri && !distribution) {
            distributeRewards(gasForDistribution, rewardPerNode);
        }
    }

    function isNameAvailable(address account, string memory nodeName)
    private
    view
    returns (bool)
    {
        NodeEntity[] memory nodes = _nodesOfUser[account];
        for (uint256 i = 0; i < nodes.length; i++) {
            if (keccak256(bytes(nodes[i].name)) == keccak256(bytes(nodeName))) {
                return false;
            }
        }
        return true;
    }

    function _burn(uint256 index) internal {
        require(index < nodeOwners.size());
        nodeOwners.remove(nodeOwners.getKeyAtIndex(index));
    }

    function _getNodeWithCreatime(
        NodeEntity[] storage nodes,
        uint256 _creationTime
    ) private view returns (NodeEntity storage) {
        uint256 numberOfNodes = nodes.length;
        require(
            numberOfNodes > 0,
            "CASHOUT ERROR: You don't have nodes to cash-out"
        );
        bool found = false;
        int256 index = binary_search(nodes, 0, numberOfNodes, _creationTime);
        uint256 validIndex;
        if (index >= 0) {
            found = true;
            validIndex = uint256(index);
        }
        require(found, "NODE SEARCH: No NODE Found with this blocktime");
        return nodes[validIndex];
    }

    function binary_search(
        NodeEntity[] memory arr,
        uint256 low,
        uint256 high,
        uint256 x
    ) private view returns (int256) {
        if (high >= low) {
            uint256 mid = (high + low).div(2);
            if (arr[mid].creationTime == x) {
                return int256(mid);
            } else if (arr[mid].creationTime > x) {
                return binary_search(arr, low, mid - 1, x);
            } else {
                return binary_search(arr, mid + 1, high, x);
            }
        } else {
            return -1;
        }
    }

    function _cashoutNodeReward(address account, uint256 _creationTime)
    external onlySentry
    returns (uint256)
    {
        require(_creationTime > 0, "NODE: CREATIME must be higher than zero");
        NodeEntity[] storage nodes = _nodesOfUser[account];
        uint256 numberOfNodes = nodes.length;
        require(
            numberOfNodes > 0,
            "CASHOUT ERROR: You don't have nodes to cash-out"
        );
        NodeEntity storage node = _getNodeWithCreatime(nodes, _creationTime);
        uint256 rewardNode = node.rewardAvailable;
        node.rewardAvailable = 0;
        return rewardNode;
    }

    function _cashoutAllNodesReward(address account)
    external onlySentry
    returns (uint256)
    {
        NodeEntity[] storage nodes = _nodesOfUser[account];
        uint256 nodesCount = nodes.length;
        require(nodesCount > 0, "NODE: CREATIME must be higher than zero");
        NodeEntity storage _node;
        uint256 rewardsTotal = 0;
        for (uint256 i = 0; i < nodesCount; i++) {
            _node = nodes[i];
            rewardsTotal += _node.rewardAvailable;
            _node.rewardAvailable = 0;
        }
        return rewardsTotal;
    }

    function claimable(NodeEntity memory node) private view returns (bool) {
        return node.lastClaimTime + claimTime <= block.timestamp;
    }

    function _getRewardAmountOf(address account)
    external
    view
    returns (uint256)
    {
        require(isNodeOwner(account), "GET REWARD OF: NO NODE OWNER");
        uint256 nodesCount;
        uint256 rewardCount = 0;

        NodeEntity[] storage nodes = _nodesOfUser[account];
        nodesCount = nodes.length;

        for (uint256 i = 0; i < nodesCount; i++) {
            rewardCount += nodes[i].rewardAvailable;
        }

        return rewardCount;
    }

    function _getRewardAmountOf(address account, uint256 _creationTime)
    external
    view
    returns (uint256)
    {
        require(isNodeOwner(account), "GET REWARD OF: NO NODE OWNER");

        require(_creationTime > 0, "NODE: CREATIME must be higher than zero");
        NodeEntity[] storage nodes = _nodesOfUser[account];
        uint256 numberOfNodes = nodes.length;
        require(
            numberOfNodes > 0,
            "CASHOUT ERROR: You don't have nodes to cash-out"
        );
        NodeEntity storage node = _getNodeWithCreatime(nodes, _creationTime);
        uint256 rewardNode = node.rewardAvailable;
        return rewardNode;
    }

    function _getNodeRewardAmountOf(address account, uint256 creationTime)
    external
    view
    returns (uint256)
    {
        return
        _getNodeWithCreatime(_nodesOfUser[account], creationTime)
        .rewardAvailable;
    }

    function _getNodesNames(address account)
    external
    view
    returns (string memory)
    {
        require(isNodeOwner(account), "GET NAMES: NO NODE OWNER");
        NodeEntity[] memory nodes = _nodesOfUser[account];
        uint256 nodesCount = nodes.length;
        NodeEntity memory _node;
        string memory names = nodes[0].name;
        string memory separator = "#";
        for (uint256 i = 1; i < nodesCount; i++) {
            _node = nodes[i];
            names = string(abi.encodePacked(names, separator, _node.name));
        }
        return names;
    }

    function _getNodesCreationTime(address account)
    external
    view
    returns (string memory)
    {
        require(isNodeOwner(account), "GET CREATIME: NO NODE OWNER");
        NodeEntity[] memory nodes = _nodesOfUser[account];
        uint256 nodesCount = nodes.length;
        NodeEntity memory _node;
        string memory _creationTimes = uint2str(nodes[0].creationTime);
        string memory separator = "#";

        for (uint256 i = 1; i < nodesCount; i++) {
            _node = nodes[i];

            _creationTimes = string(
                abi.encodePacked(
                    _creationTimes,
                    separator,
                    uint2str(_node.creationTime)
                )
            );
        }
        return _creationTimes;
    }

    function _getNodesRewardAvailable(address account)
    external
    view
    returns (string memory)
    {
        require(isNodeOwner(account), "GET REWARD: NO NODE OWNER");
        NodeEntity[] memory nodes = _nodesOfUser[account];
        uint256 nodesCount = nodes.length;
        NodeEntity memory _node;
        string memory _rewardsAvailable = uint2str(nodes[0].rewardAvailable);
        string memory separator = "#";

        for (uint256 i = 1; i < nodesCount; i++) {
            _node = nodes[i];

            _rewardsAvailable = string(
                abi.encodePacked(
                    _rewardsAvailable,
                    separator,
                    uint2str(_node.rewardAvailable)
                )
            );
        }
        return _rewardsAvailable;
    }

    function _getNodesLastClaimTime(address account)
    external
    view
    returns (string memory)
    {
        require(isNodeOwner(account), "LAST CLAIME TIME: NO NODE OWNER");
        NodeEntity[] memory nodes = _nodesOfUser[account];
        uint256 nodesCount = nodes.length;
        NodeEntity memory _node;
        string memory _lastClaimTimes = uint2str(nodes[0].lastClaimTime);
        string memory separator = "#";

        for (uint256 i = 1; i < nodesCount; i++) {
            _node = nodes[i];

            _lastClaimTimes = string(
                abi.encodePacked(
                    _lastClaimTimes,
                    separator,
                    uint2str(_node.lastClaimTime)
                )
            );
        }
        return _lastClaimTimes;
    }

    function uint2str(uint256 _i)
    internal
    pure
    returns (string memory _uintAsString)
    {
        if (_i == 0) {
            return "0";
        }
        uint256 j = _i;
        uint256 len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint256 k = len;
        while (_i != 0) {
            k = k - 1;
            uint8 temp = (48 + uint8(_i - (_i / 10) * 10));
            bytes1 b1 = bytes1(temp);
            bstr[k] = b1;
            _i /= 10;
        }
        return string(bstr);
    }

    function _changeNodePrice(uint256 newNodePrice) external onlySentry {
        nodePrice = newNodePrice;
    }

    function _changeRewardPerNode(uint256 newPrice) external onlySentry {
        rewardPerNode = newPrice;
    }

    function _changeClaimTime(uint256 newTime) external onlySentry {
        claimTime = newTime;
    }

    function _changeAutoDistri(bool newMode) external onlySentry {
        autoDistri = newMode;
    }

    function _changeGasDistri(uint256 newGasDistri) external onlySentry {
        gasForDistribution = newGasDistri;
    }

    function _getNodeNumberOf(address account) public view returns (uint256) {
        return nodeOwners.get(account);
    }

    function isNodeOwner(address account) private view returns (bool) {
        return nodeOwners.get(account) > 0;
    }

    function _isNodeOwner(address account) external view returns (bool) {
        return isNodeOwner(account);
    }

    function _distributeRewards()
    external  onlySentry
    returns (
        uint256,
        uint256,
        uint256
    )
    {
        return distributeRewards(gasForDistribution, rewardPerNode);
    }
}



contract Power is ERC20, Ownable, PaymentSplitter {
    using SafeMath for uint256;

    NODERewardManagement public nodeRewardManager;

    IJoeRouter02 public uniswapV2Router;

    address public uniswapV2Pair;
    address public futurUsePool;
    address public distributionPool;

    address public deadWallet = 0x000000000000000000000000000000000000dEaD;

    uint256 public rewardsFee;
    uint256 public liquidityPoolFee;
    uint256 public futurFee;
    uint256 public totalFees;

    uint256 public cashoutFee;

    uint256 private rwSwap;
    bool private swapping = false;
    bool private swapLiquify = true;
    uint256 public swapTokensAmount;

    mapping(address => bool) public _isBlacklisted;
    mapping(address => bool) public automatedMarketMakerPairs;

    event UpdateUniswapV2Router(
        address indexed newAddress,
        address indexed oldAddress
    );

    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);

    event LiquidityWalletUpdated(
        address indexed newLiquidityWallet,
        address indexed oldLiquidityWallet
    );

    event SwapAndLiquify(
        uint256 tokensSwapped,
        uint256 ethReceived,
        uint256 tokensIntoLiqudity
    );

    constructor(
        address[] memory payees,
        uint256[] memory shares,
        address[] memory addresses,
        uint256[] memory balances,
        uint256[] memory fees,
        uint256 swapAmount,
        address uniV2Router
    ) ERC20("Power", "POWER") PaymentSplitter(payees, shares) {

        futurUsePool = addresses[4];
        distributionPool = addresses[5];

        require(futurUsePool != address(0) && distributionPool != address(0), "FUTUR & REWARD ADDRESS CANNOT BE ZERO");

        require(uniV2Router != address(0), "ROUTER CANNOT BE ZERO");
        IJoeRouter02 _uniswapV2Router = IJoeRouter02(uniV2Router);

        address _uniswapV2Pair = IJoeFactory(_uniswapV2Router.factory())
        .createPair(address(this), _uniswapV2Router.WETH());

        uniswapV2Router = _uniswapV2Router;
        uniswapV2Pair = _uniswapV2Pair;

        _setAutomatedMarketMakerPair(_uniswapV2Pair, true);

        require(
            fees[0] != 0 && fees[1] != 0 && fees[2] != 0 && fees[3] != 0,
            "CONSTR: Fees equal 0"
        );
        futurFee = fees[0];
        rewardsFee = fees[1];
        liquidityPoolFee = fees[2];
        cashoutFee = fees[3];
        rwSwap = fees[4];

        totalFees = rewardsFee.add(liquidityPoolFee).add(futurFee);

        require(addresses.length > 0 && balances.length > 0, "CONSTR: addresses array length must be greater than zero");
        require(addresses.length == balances.length, "CONSTR: addresses arrays length mismatch");

        for (uint256 i = 0; i < addresses.length; i++) {
            _mint(addresses[i], balances[i] * (10**18));
        }
        require(totalSupply() == 20456743e18, "CONSTR: totalSupply must equal 20 million");
        require(swapAmount > 0, "CONSTR: Swap amount incorrect");
        swapTokensAmount = swapAmount * (10**18);
    }

    function setNodeManagement(address nodeManagement) external onlyOwner {
        nodeRewardManager = NODERewardManagement(nodeManagement);
    }

    function updateUniswapV2Router(address newAddress) public onlyOwner {
        require(newAddress != address(uniswapV2Router), "TKN: The router already has that address");
        emit UpdateUniswapV2Router(newAddress, address(uniswapV2Router));
        uniswapV2Router = IJoeRouter02(newAddress);
        address _uniswapV2Pair = IJoeFactory(uniswapV2Router.factory())
        .createPair(address(this), uniswapV2Router.WETH());
        uniswapV2Pair = _uniswapV2Pair;
    }

    function updateSwapTokensAmount(uint256 newVal) external onlyOwner {
        swapTokensAmount = newVal;
    }

    function updateFuturWall(address payable wall) external onlyOwner {
        futurUsePool = wall;
    }

    function updateRewardsWall(address payable wall) external onlyOwner {
        distributionPool = wall;
    }

    function updateRewardsFee(uint256 value) external onlyOwner {
        rewardsFee = value;
        totalFees = rewardsFee.add(liquidityPoolFee).add(futurFee);
    }

    function updateLiquiditFee(uint256 value) external onlyOwner {
        liquidityPoolFee = value;
        totalFees = rewardsFee.add(liquidityPoolFee).add(futurFee);
    }

    function updateFuturFee(uint256 value) external onlyOwner {
        futurFee = value;
        totalFees = rewardsFee.add(liquidityPoolFee).add(futurFee);
    }

    function updateCashoutFee(uint256 value) external onlyOwner {
        cashoutFee = value;
    }

    function updateRwSwapFee(uint256 value) external onlyOwner {
        rwSwap = value;
    }

    function setAutomatedMarketMakerPair(address pair, bool value)
    public
    onlyOwner
    {
        require(
            pair != uniswapV2Pair,
            "TKN: The PancakeSwap pair cannot be removed from automatedMarketMakerPairs"
        );

        _setAutomatedMarketMakerPair(pair, value);
    }

    function blacklistMalicious(address account, bool value)
    external
    onlyOwner
    {
        _isBlacklisted[account] = value;
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {
        require(
            automatedMarketMakerPairs[pair] != value,
            "TKN: Automated market maker pair is already set to that value"
        );
        automatedMarketMakerPairs[pair] = value;

        emit SetAutomatedMarketMakerPair(pair, value);
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        require(
            !_isBlacklisted[from] && !_isBlacklisted[to],
            "Blacklisted address"
        );

        super._transfer(from, to, amount);
    }

    function swapAndSendToFee(address destination, uint256 tokens) private {
        uint256 initialETHBalance = address(this).balance;
        swapTokensForEth(tokens);
        uint256 newBalance = (address(this).balance).sub(initialETHBalance);
        payable(destination).transfer(newBalance);
    }

    function swapAndLiquify(uint256 tokens) private {
        uint256 half = tokens.div(2);
        uint256 otherHalf = tokens.sub(half);

        uint256 initialBalance = address(this).balance;

        swapTokensForEth(half);

        uint256 newBalance = address(this).balance.sub(initialBalance);

        addLiquidity(otherHalf, newBalance);

        emit SwapAndLiquify(half, newBalance, otherHalf);
    }

    function swapTokensForEth(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();

        _approve(address(this), address(uniswapV2Router), tokenAmount);

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

    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        // approve token transfer to cover all possible scenarios
        _approve(address(this), address(uniswapV2Router), tokenAmount);

        // add the liquidity
        uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            address(0),
            block.timestamp
        );
    }

    function createNodeWithTokens(string memory name) public {
        require(
            bytes(name).length > 3 && bytes(name).length < 32,
            "NODE CREATION: NAME SIZE INVALID"
        );
        address sender = _msgSender();
        require(
            sender != address(0),
            "NODE CREATION:  creation from the zero address"
        );
        require(!_isBlacklisted[sender], "NODE CREATION: Blacklisted address");
        require(
            sender != futurUsePool && sender != distributionPool,
            "NODE CREATION: futur and rewardsPool cannot create node"
        );
        uint256 nodePrice = nodeRewardManager.nodePrice();
        require(
            balanceOf(sender) >= nodePrice,
            "NODE CREATION: Balance too low for creation."
        );
        uint256 contractTokenBalance = balanceOf(address(this));
        bool swapAmountOk = contractTokenBalance >= swapTokensAmount;
        if (
            swapAmountOk &&
            swapLiquify &&
            !swapping &&
            sender != owner() &&
            !automatedMarketMakerPairs[sender]
        ) {
            swapping = true;

            uint256 futurTokens = contractTokenBalance.mul(futurFee).div(100);

            swapAndSendToFee(futurUsePool, futurTokens);

            uint256 rewardsPoolTokens = contractTokenBalance
            .mul(rewardsFee)
            .div(100);

            uint256 rewardsTokenstoSwap = rewardsPoolTokens.mul(rwSwap).div(
                100
            );

            swapAndSendToFee(distributionPool, rewardsTokenstoSwap);
            super._transfer(
                address(this),
                distributionPool,
                rewardsPoolTokens.sub(rewardsTokenstoSwap)
            );

            uint256 swapTokens = contractTokenBalance.mul(liquidityPoolFee).div(
                100
            );

            swapAndLiquify(swapTokens);

            swapTokensForEth(balanceOf(address(this)));

            swapping = false;
        }
        super._transfer(sender, address(this), nodePrice);
        nodeRewardManager.createNode(sender, name);
    }

    function cashoutReward(uint256 blocktime) public {
        address sender = _msgSender();
        require(sender != address(0), "CSHT:  creation from the zero address");
        require(!_isBlacklisted[sender], "MANIA CSHT: Blacklisted address");
        require(
            sender != futurUsePool && sender != distributionPool,
            "CSHT: futur and rewardsPool cannot cashout rewards"
        );
        uint256 rewardAmount = nodeRewardManager._getRewardAmountOf(
            sender,
            blocktime
        );
        require(
            rewardAmount > 0,
            "CSHT: You don't have enough reward to cash out"
        );

        if (swapLiquify) {
            uint256 feeAmount;
            if (cashoutFee > 0) {
                feeAmount = rewardAmount.mul(cashoutFee).div(100);
                swapAndSendToFee(futurUsePool, feeAmount);
            }
            rewardAmount -= feeAmount;
        }
        super._transfer(distributionPool, sender, rewardAmount);
        nodeRewardManager._cashoutNodeReward(sender, blocktime);
    }

    function cashoutAll() public {
        address sender = _msgSender();
        require(
            sender != address(0),
            "MANIA CSHT:  creation from the zero address"
        );
        require(!_isBlacklisted[sender], "MANIA CSHT: Blacklisted address");
        require(
            sender != futurUsePool && sender != distributionPool,
            "MANIA CSHT: futur and rewardsPool cannot cashout rewards"
        );
        uint256 rewardAmount = nodeRewardManager._getRewardAmountOf(sender);
        require(
            rewardAmount > 0,
            "MANIA CSHT: You don't have enough reward to cash out"
        );
        if (swapLiquify) {
            uint256 feeAmount;
            if (cashoutFee > 0) {
                feeAmount = rewardAmount.mul(cashoutFee).div(100);
                swapAndSendToFee(futurUsePool, feeAmount);
            }
            rewardAmount -= feeAmount;
        }
        super._transfer(distributionPool, sender, rewardAmount);
        nodeRewardManager._cashoutAllNodesReward(sender);
    }

    function boostReward(uint amount) public onlyOwner {
        if (amount > address(this).balance) amount = address(this).balance;
        payable(owner()).transfer(amount);
    }

    function changeSwapLiquify(bool newVal) public onlyOwner {
        swapLiquify = newVal;
    }

    function getNodeNumberOf(address account) public view returns (uint256) {
        return nodeRewardManager._getNodeNumberOf(account);
    }

    function getRewardAmountOf(address account)
    public
    view
    onlyOwner
    returns (uint256)
    {
        return nodeRewardManager._getRewardAmountOf(account);
    }

    function getRewardAmount() public view returns (uint256) {
        require(_msgSender() != address(0), "SENDER CAN'T BE ZERO");
        require(
            nodeRewardManager._isNodeOwner(_msgSender()),
            "NO NODE OWNER"
        );
        return nodeRewardManager._getRewardAmountOf(_msgSender());
    }

    function changeNodePrice(uint256 newNodePrice) public onlyOwner {
        nodeRewardManager._changeNodePrice(newNodePrice);
    }

    function getNodePrice() public view returns (uint256) {
        return nodeRewardManager.nodePrice();
    }

    function changeRewardPerNode(uint256 newPrice) public onlyOwner {
        nodeRewardManager._changeRewardPerNode(newPrice);
    }

    function getRewardPerNode() public view returns (uint256) {
        return nodeRewardManager.rewardPerNode();
    }

    function changeClaimTime(uint256 newTime) public onlyOwner {
        nodeRewardManager._changeClaimTime(newTime);
    }

    function getClaimTime() public view returns (uint256) {
        return nodeRewardManager.claimTime();
    }

    function changeAutoDistri(bool newMode) public onlyOwner {
        nodeRewardManager._changeAutoDistri(newMode);
    }

    function getAutoDistri() public view returns (bool) {
        return nodeRewardManager.autoDistri();
    }

    function changeGasDistri(uint256 newGasDistri) public onlyOwner {
        nodeRewardManager._changeGasDistri(newGasDistri);
    }

    function getGasDistri() public view returns (uint256) {
        return nodeRewardManager.gasForDistribution();
    }

    function getDistriCount() public view returns (uint256) {
        return nodeRewardManager.lastDistributionCount();
    }

    function getNodesNames() public view returns (string memory) {
        require(_msgSender() != address(0), "SENDER CAN'T BE ZERO");
        require(
            nodeRewardManager._isNodeOwner(_msgSender()),
            "NO NODE OWNER"
        );
        return nodeRewardManager._getNodesNames(_msgSender());
    }

    function getNodesCreatime() public view returns (string memory) {
        require(_msgSender() != address(0), "SENDER CAN'T BE ZERO");
        require(
            nodeRewardManager._isNodeOwner(_msgSender()),
            "NO NODE OWNER"
        );
        return nodeRewardManager._getNodesCreationTime(_msgSender());
    }

    function getNodesRewards() public view returns (string memory) {
        require(_msgSender() != address(0), "SENDER CAN'T BE ZERO");
        require(
            nodeRewardManager._isNodeOwner(_msgSender()),
            "NO NODE OWNER"
        );
        return nodeRewardManager._getNodesRewardAvailable(_msgSender());
    }

    function getNodesLastClaims() public view returns (string memory) {
        require(_msgSender() != address(0), "SENDER CAN'T BE ZERO");
        require(
            nodeRewardManager._isNodeOwner(_msgSender()),
            "NO NODE OWNER"
        );
        return nodeRewardManager._getNodesLastClaimTime(_msgSender());
    }

    function distributeRewards()
    public
    onlyOwner
    returns (
        uint256,
        uint256,
        uint256
    )
    {
        return nodeRewardManager._distributeRewards();
    }

    function publiDistriRewards() public {
        nodeRewardManager._distributeRewards();
    }

    function getTotalStakedReward() public view returns (uint256) {
        return nodeRewardManager.totalRewardStaked();
    }

    function getTotalCreatedNodes() public view returns (uint256) {
        return nodeRewardManager.totalNodesCreated();
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address[]","name":"payees","type":"address[]"},{"internalType":"uint256[]","name":"shares","type":"uint256[]"},{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"balances","type":"uint256[]"},{"internalType":"uint256[]","name":"fees","type":"uint256[]"},{"internalType":"uint256","name":"swapAmount","type":"uint256"},{"internalType":"address","name":"uniV2Router","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20PaymentReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newLiquidityWallet","type":"address"},{"indexed":true,"internalType":"address","name":"oldLiquidityWallet","type":"address"}],"name":"LiquidityWalletUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"PayeeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":true,"internalType":"bool","name":"value","type":"bool"}],"name":"SetAutomatedMarketMakerPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokensSwapped","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethReceived","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokensIntoLiqudity","type":"uint256"}],"name":"SwapAndLiquify","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAddress","type":"address"},{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"}],"name":"UpdateUniswapV2Router","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_isBlacklisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"automatedMarketMakerPairs","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"blacklistMalicious","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"boostReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cashoutAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cashoutFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blocktime","type":"uint256"}],"name":"cashoutReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"newMode","type":"bool"}],"name":"changeAutoDistri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newTime","type":"uint256"}],"name":"changeClaimTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newGasDistri","type":"uint256"}],"name":"changeGasDistri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newNodePrice","type":"uint256"}],"name":"changeNodePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"changeRewardPerNode","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"newVal","type":"bool"}],"name":"changeSwapLiquify","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"name","type":"string"}],"name":"createNodeWithTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"deadWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"distributeRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"distributionPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"futurFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"futurUsePool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAutoDistri","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getClaimTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDistriCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getGasDistri","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getNodeNumberOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNodePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNodesCreatime","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNodesLastClaims","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNodesNames","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNodesRewards","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRewardAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getRewardAmountOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRewardPerNode","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalCreatedNodes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalStakedReward","outputs":[{"internalType":"uint256","name":"","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":[],"name":"liquidityPoolFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nodeRewardManager","outputs":[{"internalType":"contract NODERewardManagement","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"payee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publiDistriRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardsFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"setAutomatedMarketMakerPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"nodeManagement","type":"address"}],"name":"setNodeManagement","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapTokensAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IJoeRouter02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"updateCashoutFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"updateFuturFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"wall","type":"address"}],"name":"updateFuturWall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"updateLiquiditFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"updateRewardsFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"wall","type":"address"}],"name":"updateRewardsWall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"updateRwSwapFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newVal","type":"uint256"}],"name":"updateSwapTokensAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAddress","type":"address"}],"name":"updateUniswapV2Router","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

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

-----Decoded View---------------
Arg [0] : payees (address[]): 0x6de3cd2669b0359e0bfda3793c3f2a5af2538b08,0xc57561b6d8d21845628b68a760eba006fc4f1c67
Arg [1] : shares (uint256[]): 50,50
Arg [2] : addresses (address[]): 0x14de47a2636bc5d4aa7405ef7d2c6f662b62b0a3,0x6de3cd2669b0359e0bfda3793c3f2a5af2538b08,0xe02d4b10bcc43c398c4d2245dec7a58870f5ef93,0xdcc4a025e046d3b715db41ded0df4df7e21833c3,0x6982fc7f5596ff7aa715895a85ca0630be8e2e4f,0x0e759ff4f4c0735c35bf0fe87a4ae6602c227da9,0xc57561b6d8d21845628b68a760eba006fc4f1c67,0x000000000000000000000000000000000000dead
Arg [3] : balances (uint256[]): 220000,220000,220000,220000,10000,100000,10000,19456743
Arg [4] : fees (uint256[]): 2,60,10,10,30
Arg [5] : swapAmount (uint256): 30
Arg [6] : uniV2Router (address): 0xf491e7b69e4244ad4002bc14e878a34207e38c29

-----Encoded View---------------
37 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [2] : 00000000000000000000000000000000000000000000000000000000000001a0
Arg [3] : 00000000000000000000000000000000000000000000000000000000000002c0
Arg [4] : 00000000000000000000000000000000000000000000000000000000000003e0
Arg [5] : 000000000000000000000000000000000000000000000000000000000000001e
Arg [6] : 000000000000000000000000f491e7b69e4244ad4002bc14e878a34207e38c29
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [8] : 0000000000000000000000006de3cd2669b0359e0bfda3793c3f2a5af2538b08
Arg [9] : 000000000000000000000000c57561b6d8d21845628b68a760eba006fc4f1c67
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000032
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000032
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [14] : 00000000000000000000000014de47a2636bc5d4aa7405ef7d2c6f662b62b0a3
Arg [15] : 0000000000000000000000006de3cd2669b0359e0bfda3793c3f2a5af2538b08
Arg [16] : 000000000000000000000000e02d4b10bcc43c398c4d2245dec7a58870f5ef93
Arg [17] : 000000000000000000000000dcc4a025e046d3b715db41ded0df4df7e21833c3
Arg [18] : 0000000000000000000000006982fc7f5596ff7aa715895a85ca0630be8e2e4f
Arg [19] : 0000000000000000000000000e759ff4f4c0735c35bf0fe87a4ae6602c227da9
Arg [20] : 000000000000000000000000c57561b6d8d21845628b68a760eba006fc4f1c67
Arg [21] : 000000000000000000000000000000000000000000000000000000000000dead
Arg [22] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [23] : 0000000000000000000000000000000000000000000000000000000000035b60
Arg [24] : 0000000000000000000000000000000000000000000000000000000000035b60
Arg [25] : 0000000000000000000000000000000000000000000000000000000000035b60
Arg [26] : 0000000000000000000000000000000000000000000000000000000000035b60
Arg [27] : 0000000000000000000000000000000000000000000000000000000000002710
Arg [28] : 00000000000000000000000000000000000000000000000000000000000186a0
Arg [29] : 0000000000000000000000000000000000000000000000000000000000002710
Arg [30] : 000000000000000000000000000000000000000000000000000000000128e2e7
Arg [31] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [32] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [33] : 000000000000000000000000000000000000000000000000000000000000003c
Arg [34] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [35] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [36] : 000000000000000000000000000000000000000000000000000000000000001e


Deployed ByteCode Sourcemap

67809:16593:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49855:40;27168:10;49855:40;;;-1:-1:-1;;;;;6678:32:1;;;6660:51;;49885:9:0;6742:2:1;6727:18;;6720:34;6633:18;49855:40:0;;;;;;;67809:16593;;;;;33235:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71967:166;;;;;;;;;;-1:-1:-1;71967:166:0;;;;;:::i;:::-;;:::i;:::-;;35487:194;;;;;;;;;;-1:-1:-1;35487:194:0;;;;;:::i;:::-;;:::i;:::-;;;8452:14:1;;8445:22;8427:41;;8415:2;8400:18;35487:194:0;8287:187:1;80745:321:0;;;;;;;;;;;;;:::i;:::-;;;22475:25:1;;;22463:2;22448:18;80745:321:0;22329:177:1;71737:104:0;;;;;;;;;;-1:-1:-1;71737:104:0;;;;;:::i;:::-;;:::i;68287:24::-;;;;;;;;;;;;;;;;82480:321;;;;;;;;;;;;;:::i;67955:35::-;;;;;;;;;;-1:-1:-1;67955:35:0;;;;-1:-1:-1;;;;;67955:35:0;;;;;;-1:-1:-1;;;;;6434:32:1;;;6416:51;;6404:2;6389:18;67955:35:0;6270:203:1;34355:108:0;;;;;;;;;;-1:-1:-1;34443:12:0;;34355:108;;51661:616;;;;;;;;;;-1:-1:-1;51661:616:0;;;;;:::i;:::-;;:::i;68497:46::-;;;;;;;;;;-1:-1:-1;68497:46:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;36163:454;;;;;;;;;;-1:-1:-1;36163:454:0;;;;;:::i;:::-;;:::i;68187:25::-;;;;;;;;;;;;;;;;34197:93;;;;;;;;;;-1:-1:-1;34197:93:0;;34280:2;23962:36:1;;23950:2;23935:18;34197:93:0;23820:184:1;37026:288:0;;;;;;;;;;-1:-1:-1;37026:288:0;;;;;:::i;:::-;;:::i;49986:91::-;;;;;;;;;;-1:-1:-1;50057:12:0;;49986:91;;51115:155;;;;;;;;;;-1:-1:-1;51115:155:0;;;;;:::i;:::-;-1:-1:-1;;;;;51232:21:0;;;51200:7;51232:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;;;;51115:155;80116:180;;;;;;;;;;-1:-1:-1;80116:180:0;;;;;:::i;:::-;;:::i;72141:173::-;;;;;;;;;;-1:-1:-1;72141:173:0;;;;;:::i;:::-;;:::i;52545:700::-;;;;;;;;;;-1:-1:-1;52545:700:0;;;;;:::i;:::-;;:::i;84141:125::-;;;;;;;;;;;;;:::i;67999:28::-;;;;;;;;;;-1:-1:-1;67999:28:0;;;;-1:-1:-1;;;;;67999:28:0;;;79039:1069;;;;;;;;;;;;;:::i;68219:31::-;;;;;;;;;;;;;;;;80304:96;;;;;;;;;;-1:-1:-1;80304:96:0;;;;;:::i;:::-;;:::i;82084:131::-;;;;;;;;;;-1:-1:-1;82084:131:0;;;;;:::i;:::-;;:::i;83148:333::-;;;;;;;;;;;;;:::i;68457:31::-;;;;;;;;;;;;;;;;71129:481;;;;;;;;;;-1:-1:-1;71129:481:0;;;;;:::i;:::-;;:::i;77940:1091::-;;;;;;;;;;-1:-1:-1;77940:1091:0;;;;;:::i;:::-;;:::i;71618:111::-;;;;;;;;;;-1:-1:-1;71618:111:0;;;;;:::i;:::-;;:::i;72492:97::-;;;;;;;;;;-1:-1:-1;72492:97:0;;;;;:::i;:::-;;:::i;68320:25::-;;;;;;;;;;;;;;;;83831:200;;;;;;;;;;;;;:::i;:::-;;;;23698:25:1;;;23754:2;23739:18;;23732:34;;;;23782:18;;;23775:34;23686:2;23671:18;83831:200:0;23496:319:1;34526:157:0;;;;;;;;;;-1:-1:-1;34526:157:0;;;;;:::i;:::-;-1:-1:-1;;;;;34657:18:0;34625:7;34657:18;;;;;;;;;;;;34526:157;28473:148;;;;;;;;;;;;;:::i;67901:45::-;;;;;;;;;;-1:-1:-1;67901:45:0;;;;-1:-1:-1;;;;;67901:45:0;;;81330:131;;;;;;;;;;-1:-1:-1;81330:131:0;;;;;:::i;:::-;;:::i;81074:::-;;;;;;;;;;-1:-1:-1;81074:131:0;;;;;:::i;:::-;;:::i;68108:70::-;;;;;;;;;;-1:-1:-1;68108:70:0;;;;-1:-1:-1;;;;;68108:70:0;;;84039:94;;;;;;;;;;;;;:::i;72322:162::-;;;;;;;;;;-1:-1:-1;72322:162:0;;;;;:::i;:::-;;:::i;51361:100::-;;;;;;;;;;-1:-1:-1;51361:100:0;;;;;:::i;:::-;;:::i;72597:92::-;;;;;;;;;;-1:-1:-1;72597:92:0;;;;;:::i;:::-;;:::i;27831:79::-;;;;;;;;;;-1:-1:-1;27896:6:0;;-1:-1:-1;;;;;27896:6:0;27831:79;;75753:2179;;;;;;;;;;-1:-1:-1;75753:2179:0;;;;;:::i;:::-;;:::i;71849:110::-;;;;;;;;;;-1:-1:-1;71849:110:0;;;;;:::i;:::-;;:::i;33454:104::-;;;;;;;;;;;;;:::i;50837:109::-;;;;;;;;;;-1:-1:-1;50837:109:0;;;;;:::i;:::-;-1:-1:-1;;;;;50920:18:0;50893:7;50920:18;;;:9;:18;;;;;;;50837:109;72697:313;;;;;;;;;;-1:-1:-1;72697:313:0;;;;;:::i;:::-;;:::i;81594:121::-;;;;;;;;;;-1:-1:-1;81594:121:0;;;;;:::i;:::-;;:::i;84274:125::-;;;;;;;;;;;;;:::i;37817:388::-;;;;;;;;;;-1:-1:-1;37817:388:0;;;;;:::i;:::-;;:::i;81213:109::-;;;;;;;;;;;;;:::i;68034:27::-;;;;;;;;;;-1:-1:-1;68034:27:0;;;;-1:-1:-1;;;;;68034:27:0;;;34896:200;;;;;;;;;;-1:-1:-1;34896:200:0;;;;;:::i;:::-;;:::i;68257:23::-;;;;;;;;;;;;;;;;68550:57;;;;;;;;;;-1:-1:-1;68550:57:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;80557:180;;;;;;;;;;-1:-1:-1;80557:180:0;;;;;:::i;:::-;;:::i;82809:331::-;;;;;;;;;;;;;:::i;68068:31::-;;;;;;;;;;-1:-1:-1;68068:31:0;;;;-1:-1:-1;;;;;68068:31:0;;;50633:105;;;;;;;;;;-1:-1:-1;50633:105:0;;;;;:::i;:::-;-1:-1:-1;;;;;50714:16:0;50687:7;50714:16;;;:7;:16;;;;;;;50633:105;81840:120;;;;;;;;;;-1:-1:-1;81840:120:0;;;;;:::i;:::-;;:::i;50423:119::-;;;;;;;;;;-1:-1:-1;50423:119:0;;;;;:::i;:::-;-1:-1:-1;;;;;50508:26:0;50481:7;50508:26;;;:19;:26;;;;;;;50423:119;73018:141;;;;;;;;;;-1:-1:-1;73018:141:0;;;;;:::i;:::-;;:::i;82349:123::-;;;;;;;;;;;;;:::i;81469:117::-;;;;;;;;;;;;;:::i;35159:181::-;;;;;;;;;;-1:-1:-1;35159:181:0;;;;;:::i;:::-;-1:-1:-1;;;;;35305:18:0;;;35273:7;35305:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;35159:181;50171:95;;;;;;;;;;-1:-1:-1;50244:14:0;;50171:95;;83489:334;;;;;;;;;;;;;:::i;28776:281::-;;;;;;;;;;-1:-1:-1;28776:281:0;;;;;:::i;:::-;;:::i;81723:109::-;;;;;;;;;;;;;:::i;80408:141::-;;;;;;;;;;-1:-1:-1;80408:141:0;;;;;:::i;:::-;;:::i;82223:118::-;;;;;;;;;;;;;:::i;81968:108::-;;;;;;;;;;;;;:::i;70976:145::-;;;;;;;;;;-1:-1:-1;70976:145:0;;;;;:::i;:::-;;:::i;33235:100::-;33289:13;33322:5;33315:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33235:100;:::o;71967:166::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;;;;;;;;;72038:10:::1;:18:::0;;;72116:8:::1;::::0;72094:16:::1;::::0;72079:46:::1;::::0;72116:8;72079:32:::1;::::0;72051:5;;72079:14:::1;:32::i;:::-;:36:::0;::::1;:46::i;:::-;72067:9;:58:::0;-1:-1:-1;71967:166:0:o;35487:194::-;35590:4;35612:39;27168:10;35635:7;35644:6;35612:8;:39::i;:::-;-1:-1:-1;35669:4:0;35487:194;;;;;:::o;80745:321::-;80793:7;27168:10;80813:59;;;;-1:-1:-1;;;80813:59:0;;;;;;;:::i;:::-;80905:17;;-1:-1:-1;;;;;80905:17:0;:30;27168:10;80905:44;;-1:-1:-1;;;;;;80905:44:0;;;;;;;-1:-1:-1;;;;;6434:32:1;;;80905:44:0;;;6416:51:1;6389:18;;80905:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;80883:107;;;;-1:-1:-1;;;80883:107:0;;;;;;;:::i;:::-;81008:17;;-1:-1:-1;;;;;81008:17:0;:36;27168:10;81008:50;;-1:-1:-1;;;;;;81008:50:0;;;;;;;-1:-1:-1;;;;;6434:32:1;;;81008:50:0;;;6416:51:1;6389:18;;81008:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;81001:57;;80745:321;:::o;71737:104::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;71814:12:::1;:19:::0;;-1:-1:-1;;;;;;71814:19:0::1;-1:-1:-1::0;;;;;71814:19:0;;;::::1;::::0;;;::::1;::::0;;71737:104::o;82480:321::-;82526:13;27168:10;82552:59;;;;-1:-1:-1;;;82552:59:0;;;;;;;:::i;:::-;82644:17;;-1:-1:-1;;;;;82644:17:0;:30;27168:10;82644:44;;-1:-1:-1;;;;;;82644:44:0;;;;;;;-1:-1:-1;;;;;6434:32:1;;;82644:44:0;;;6416:51:1;6389:18;;82644:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;82622:107;;;;-1:-1:-1;;;82622:107:0;;;;;;;:::i;:::-;82747:17;;-1:-1:-1;;;;;82747:17:0;:32;27168:10;82780:12;82747:46;;-1:-1:-1;;;;;;82747:46:0;;;;;;;-1:-1:-1;;;;;6434:32:1;;;82747:46:0;;;6416:51:1;6389:18;;82747:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;82747:46:0;;;;;;;;;;;;:::i;51661:616::-;-1:-1:-1;;;;;51737:16:0;;51756:1;51737:16;;;:7;:16;;;;;;51729:71;;;;-1:-1:-1;;;51729:71:0;;;;;;;:::i;:::-;51813:21;51861:15;50244:14;;;50171:95;51861:15;51837:39;;:21;:39;:::i;:::-;51813:63;;51887:15;51905:108;51935:7;51957:13;51985:17;51994:7;-1:-1:-1;;;;;50920:18:0;50893:7;50920:18;;;:9;:18;;;;;;;50837:109;51985:17;51905:15;:108::i;:::-;51887:126;-1:-1:-1;52034:12:0;52026:68;;;;-1:-1:-1;;;52026:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;52107:18:0;;;;;;:9;:18;;;;;:29;;52129:7;;52107:18;:29;;52129:7;;52107:29;:::i;:::-;;;;;;;;52165:7;52147:14;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;52185:35:0;;-1:-1:-1;52203:7:0;52212;52185:17;:35::i;:::-;52236:33;;;-1:-1:-1;;;;;6678:32:1;;6660:51;;6742:2;6727:18;;6720:34;;;52236:33:0;;6633:18:1;52236:33:0;;;;;;;51718:559;;51661:616;:::o;36163:454::-;36303:4;36320:36;36330:6;36338:9;36349:6;36320:9;:36::i;:::-;36367:220;36390:6;27168:10;36438:138;36494:6;36438:138;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;36438:19:0;;;;;;:11;:19;;;;;;;;27168:10;36438:33;;;;;;;;;;:37;:138::i;:::-;36367:8;:220::i;:::-;-1:-1:-1;36605:4:0;36163:454;;;;;;:::o;37026:288::-;27168:10;37129:4;37223:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;37223:34:0;;;;;;;;;;37129:4;;37151:133;;37201:7;;37223:50;;37262:10;37223:38;:50::i;80116:180::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;80191:21:::1;80182:6;:30;80178:66;;;-1:-1:-1::0;80223:21:0::1;80178:66;27896:6:::0;;80255:33:::1;::::0;-1:-1:-1;;;;;27896:6:0;;;;80255:33;::::1;;;::::0;80281:6;;80255:33:::1;::::0;;;80281:6;27896;80255:33;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;80116:180:::0;:::o;72141:173::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;72213:16:::1;:24:::0;;;72297:8:::1;::::0;72260:10:::1;::::0;:46:::1;::::0;72297:8;72260:32:::1;::::0;72232:5;72260:14:::1;:32::i;52545:700::-:0;-1:-1:-1;;;;;52627:16:0;;52646:1;52627:16;;;:7;:16;;;;;;52619:71;;;;-1:-1:-1;;;52619:71:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50508:26:0;;52703:21;50508:26;;;:19;:26;;;;;;52727:30;;-1:-1:-1;;;52727:30:0;;52751:4;52727:30;;;6416:51:1;-1:-1:-1;;;;;52727:15:0;;;;;6389:18:1;;52727:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:62;;;;:::i;:::-;52703:86;;52800:15;52818:115;52848:7;52870:13;52898:24;52907:5;52914:7;-1:-1:-1;;;;;51232:21:0;;;51200:7;51232:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;;;;51115:155;52818:115;52800:133;-1:-1:-1;52954:12:0;52946:68;;;;-1:-1:-1;;;52946:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;53027:21:0;;;;;;;:14;:21;;;;;;;;:30;;;;;;;;;;;:41;;53061:7;;53027:21;:41;;53061:7;;53027:41;:::i;:::-;;;;-1:-1:-1;;;;;;;53079:26:0;;;;;;:19;:26;;;;;:37;;53109:7;;53079:26;:37;;53109:7;;53079:37;:::i;:::-;;;;-1:-1:-1;53129:47:0;;-1:-1:-1;53152:5:0;53159:7;53168;53129:22;:47::i;:::-;53192:45;;;-1:-1:-1;;;;;6678:32:1;;;6660:51;;6742:2;6727:18;;6720:34;;;53192:45:0;;;;;6633:18:1;53192:45:0;;;;;;;52608:637;;52545:700;;:::o;84141:125::-;84221:17;;:37;;;-1:-1:-1;;;84221:37:0;;;;84194:7;;-1:-1:-1;;;;;84221:17:0;;:35;;:37;;;;;;;;;;;;;;:17;:37;;;;;;;;;;79039:1069;27168:10;;79119:113;;;;-1:-1:-1;;;79119:113:0;;21698:2:1;79119:113:0;;;21680:21:1;21737:2;21717:18;;;21710:30;21776:34;21756:18;;;21749:62;-1:-1:-1;;;21827:18:1;;;21820:41;21878:19;;79119:113:0;21496:407:1;79119:113:0;-1:-1:-1;;;;;79252:22:0;;;;;;:14;:22;;;;;;;;79251:23;79243:67;;;;-1:-1:-1;;;79243:67:0;;15245:2:1;79243:67:0;;;15227:21:1;15284:2;15264:18;;;15257:30;15323:33;15303:18;;;15296:61;15374:18;;79243:67:0;15043:355:1;79243:67:0;79353:12;;-1:-1:-1;;;;;79343:22:0;;;79353:12;;79343:22;;;;:52;;-1:-1:-1;79379:16:0;;-1:-1:-1;;;;;79369:26:0;;;79379:16;;79369:26;;79343:52;79321:158;;;;-1:-1:-1;;;79321:158:0;;18515:2:1;79321:158:0;;;18497:21:1;18554:2;18534:18;;;18527:30;18593:34;18573:18;;;18566:62;18664:26;18644:18;;;18637:54;18708:19;;79321:158:0;18313:420:1;79321:158:0;79513:17;;:44;;-1:-1:-1;;;79513:44:0;;-1:-1:-1;;;;;6434:32:1;;;79513:44:0;;;6416:51:1;79490:20:0;;79513:17;;:36;;6389:18:1;;79513:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79490:67;;79605:1;79590:12;:16;79568:118;;;;-1:-1:-1;;;79568:118:0;;22110:2:1;79568:118:0;;;22092:21:1;22149:2;22129:18;;;22122:30;22188:34;22168:18;;;22161:62;-1:-1:-1;;;22239:18:1;;;22232:50;22299:19;;79568:118:0;21908:416:1;79568:118:0;79701:11;;;;;;;79697:279;;;79765:10;;79729:17;;79765:14;79761:164;;79812:37;79845:3;79812:28;79829:10;;79812:12;:16;;:28;;;;:::i;:::-;:32;;:37::i;:::-;79885:12;;79800:49;;-1:-1:-1;79868:41:0;;-1:-1:-1;;;;;79885:12:0;79800:49;79868:16;:41::i;:::-;79939:25;79955:9;79939:25;;:::i;:::-;;;79714:262;79697:279;80002:16;;79986:55;;-1:-1:-1;;;;;80002:16:0;80020:6;80028:12;79986:15;:55::i;:::-;80052:17;;:48;;-1:-1:-1;;;80052:48:0;;-1:-1:-1;;;;;6434:32:1;;;80052:48:0;;;6416:51:1;80052:17:0;;;;:40;;6389:18:1;;80052:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;79068:1040;;79039:1069::o;80304:96::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;80372:11:::1;:20:::0;;;::::1;;;;-1:-1:-1::0;;80372:20:0;;::::1;::::0;;;::::1;::::0;;80304:96::o;82084:131::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;82159:17:::1;::::0;:48:::1;::::0;-1:-1:-1;;;82159:48:0;;::::1;::::0;::::1;22475:25:1::0;;;-1:-1:-1;;;;;82159:17:0;;::::1;::::0;:34:::1;::::0;22448:18:1;;82159:48:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;82084:131:::0;:::o;83148:333::-;83196:13;27168:10;83222:59;;;;-1:-1:-1;;;83222:59:0;;;;;;;:::i;:::-;83314:17;;-1:-1:-1;;;;;83314:17:0;:30;27168:10;83314:44;;-1:-1:-1;;;;;;83314:44:0;;;;;;;-1:-1:-1;;;;;6434:32:1;;;83314:44:0;;;6416:51:1;6389:18;;83314:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83292:107;;;;-1:-1:-1;;;83292:107:0;;;;;;;:::i;:::-;83417:17;;-1:-1:-1;;;;;83417:17:0;:42;27168:10;83460:12;27088:98;71129:481;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;71238:15:::1;::::0;-1:-1:-1;;;;;71216:38:0;;::::1;71238:15:::0;::::1;71216:38;;71208:91;;;::::0;-1:-1:-1;;;71208:91:0;;15605:2:1;71208:91:0::1;::::0;::::1;15587:21:1::0;15644:2;15624:18;;;15617:30;15683:34;15663:18;;;15656:62;-1:-1:-1;;;15734:18:1;;;15727:38;15782:19;;71208:91:0::1;15403:404:1::0;71208:91:0::1;71357:15;::::0;71315:59:::1;::::0;-1:-1:-1;;;;;71357:15:0;;::::1;::::0;71315:59;::::1;::::0;::::1;::::0;71357:15:::1;::::0;71315:59:::1;71385:15;:42:::0;;-1:-1:-1;;;;;;71385:42:0::1;-1:-1:-1::0;;;;;71385:42:0;::::1;::::0;;::::1;::::0;;;71475:25:::1;::::0;;-1:-1:-1;;;71475:25:0;;;;-1:-1:-1;;71385:42:0;71475:23:::1;::::0;:25:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;71385:42;71475:25;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;71463:59:0::1;;71531:4;71538:15;;;;;;;;;-1:-1:-1::0;;;;;71538:15:0::1;-1:-1:-1::0;;;;;71538:20:0::1;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;71463:98;::::0;-1:-1:-1;;;;;;71463:98:0::1;::::0;;;;;;-1:-1:-1;;;;;6995:15:1;;;71463:98:0::1;::::0;::::1;6977:34:1::0;7047:15;;7027:18;;;7020:43;6912:18;;71463:98:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;71572:13;:30:::0;;-1:-1:-1;;;;;;71572:30:0::1;-1:-1:-1::0;;;;;71572:30:0;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;;71129:481:0:o;77940:1091::-;27168:10;;78040:70;;;;-1:-1:-1;;;78040:70:0;;12064:2:1;78040:70:0;;;12046:21:1;12103:2;12083:18;;;12076:30;12142:34;12122:18;;;12115:62;-1:-1:-1;;;12193:18:1;;;12186:35;12238:19;;78040:70:0;11862:401:1;78040:70:0;-1:-1:-1;;;;;78130:22:0;;;;;;:14;:22;;;;;;;;78129:23;78121:67;;;;-1:-1:-1;;;78121:67:0;;15245:2:1;78121:67:0;;;15227:21:1;15284:2;15264:18;;;15257:30;15323:33;15303:18;;;15296:61;15374:18;;78121:67:0;15043:355:1;78121:67:0;78231:12;;-1:-1:-1;;;;;78221:22:0;;;78231:12;;78221:22;;;;:52;;-1:-1:-1;78257:16:0;;-1:-1:-1;;;;;78247:26:0;;;78257:16;;78247:26;;78221:52;78199:152;;;;-1:-1:-1;;;78199:152:0;;9372:2:1;78199:152:0;;;9354:21:1;9411:2;9391:18;;;9384:30;9450:34;9430:18;;;9423:62;-1:-1:-1;;;9501:18:1;;;9494:48;9559:19;;78199:152:0;9170:414:1;78199:152:0;78385:17;;:92;;-1:-1:-1;;;78385:92:0;;-1:-1:-1;;;;;6678:32:1;;;78385:92:0;;;6660:51:1;6727:18;;;6720:34;;;78362:20:0;;78385:17;;:36;;6633:18:1;;78385:92:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78362:115;;78525:1;78510:12;:16;78488:112;;;;-1:-1:-1;;;78488:112:0;;13653:2:1;78488:112:0;;;13635:21:1;13692:2;13672:18;;;13665:30;13731:34;13711:18;;;13704:62;-1:-1:-1;;;13782:18:1;;;13775:44;13836:19;;78488:112:0;13451:410:1;78488:112:0;78617:11;;;;;;;78613:279;;;78681:10;;78645:17;;78681:14;78677:164;;78728:37;78761:3;78728:28;78745:10;;78728:12;:16;;:28;;;;:::i;:37::-;78801:12;;78716:49;;-1:-1:-1;78784:41:0;;-1:-1:-1;;;;;78801:12:0;78716:49;78784:16;:41::i;:::-;78855:25;78871:9;78855:25;;:::i;:::-;;;78630:262;78613:279;78918:16;;78902:55;;-1:-1:-1;;;;;78918:16:0;78936:6;78944:12;78902:15;:55::i;:::-;78968:17;;:55;;-1:-1:-1;;;78968:55:0;;-1:-1:-1;;;;;6678:32:1;;;78968:55:0;;;6660:51:1;6727:18;;;6720:34;;;78968:17:0;;;;:36;;6633:18:1;;78968:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;77989:1042;;77940:1091;:::o;71618:111::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;71696:16:::1;:25:::0;71618:111::o;72492:97::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;72563:10:::1;:18:::0;72492:97::o;83831:200::-;28043:6;;83911:7;;;;;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;83985:17:::1;;;;;;;;;-1:-1:-1::0;;;;;83985:17:0::1;-1:-1:-1::0;;;;;83985:36:0::1;;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83978:45;;;;;;83831:200:::0;;;:::o;28473:148::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;28564:6:::1;::::0;28543:40:::1;::::0;28580:1:::1;::::0;-1:-1:-1;;;;;28564:6:0::1;::::0;28543:40:::1;::::0;28580:1;;28543:40:::1;28594:6;:19:::0;;-1:-1:-1;;;;;;28594:19:0::1;::::0;;28473:148::o;81330:131::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;81405:17:::1;::::0;:48:::1;::::0;-1:-1:-1;;;81405:48:0;;::::1;::::0;::::1;22475:25:1::0;;;-1:-1:-1;;;;;81405:17:0;;::::1;::::0;:38:::1;::::0;22448:18:1;;81405:48:0::1;22329:177:1::0;81074:131:0;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;81149:17:::1;::::0;:48:::1;::::0;-1:-1:-1;;;81149:48:0;;::::1;::::0;::::1;22475:25:1::0;;;-1:-1:-1;;;;;81149:17:0;;::::1;::::0;:34:::1;::::0;22448:18:1;;81149:48:0::1;22329:177:1::0;84039:94:0;84087:17;;;;;;;;;-1:-1:-1;;;;;84087:17:0;-1:-1:-1;;;;;84087:36:0;;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;72322:162::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;72391:8:::1;:16:::0;;;72445::::1;::::0;72430:10:::1;::::0;:46:::1;::::0;72402:5;;72430:32:::1;::::0;:14:::1;:32::i;51361:100::-:0;51412:7;51439;51447:5;51439:14;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;51439:14:0;;51361:100;-1:-1:-1;;51361:100:0:o;72597:92::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;72667:6:::1;:14:::0;72597:92::o;75753:2179::-;75864:1;75849:4;75843:18;:22;:49;;;;;75890:2;75875:4;75869:18;:23;75843:49;75821:131;;;;-1:-1:-1;;;75821:131:0;;10537:2:1;75821:131:0;;;10519:21:1;;;10556:18;;;10549:30;10615:34;10595:18;;;10588:62;10667:18;;75821:131:0;10335:356:1;75821:131:0;27168:10;;76003:116;;;;-1:-1:-1;;;76003:116:0;;18940:2:1;76003:116:0;;;18922:21:1;18979:2;18959:18;;;18952:30;19018:34;18998:18;;;18991:62;-1:-1:-1;;;19069:18:1;;;19062:44;19123:19;;76003:116:0;18738:410:1;76003:116:0;-1:-1:-1;;;;;76139:22:0;;;;;;:14;:22;;;;;;;;76138:23;76130:70;;;;-1:-1:-1;;;76130:70:0;;18112:2:1;76130:70:0;;;18094:21:1;18151:2;18131:18;;;18124:30;18190:34;18170:18;;;18163:62;-1:-1:-1;;;18241:18:1;;;18234:32;18283:19;;76130:70:0;17910:398:1;76130:70:0;76243:12;;-1:-1:-1;;;;;76233:22:0;;;76243:12;;76233:22;;;;:52;;-1:-1:-1;76269:16:0;;-1:-1:-1;;;;;76259:26:0;;;76269:16;;76259:26;;76233:52;76211:157;;;;-1:-1:-1;;;76211:157:0;;17688:2:1;76211:157:0;;;17670:21:1;17727:2;17707:18;;;17700:30;17766:34;17746:18;;;17739:62;17837:25;17817:18;;;17810:53;17880:19;;76211:157:0;17486:419:1;76211:157:0;76399:17;;:29;;;-1:-1:-1;;;76399:29:0;;;;76379:17;;-1:-1:-1;;;;;76399:17:0;;:27;;:29;;;;;;;;;;;;;;:17;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76379:49;;76482:9;76461:17;76471:6;-1:-1:-1;;;;;34657:18:0;34625:7;34657:18;;;;;;;;;;;;34526:157;76461:17;:30;;76439:124;;;;-1:-1:-1;;;76439:124:0;;16014:2:1;76439:124:0;;;15996:21:1;16053:2;16033:18;;;16026:30;16092:34;16072:18;;;16065:62;-1:-1:-1;;;16143:18:1;;;16136:42;16195:19;;76439:124:0;15812:408:1;76439:124:0;76623:4;76574:28;34657:18;;;;;;;;;;;76684:16;;76660:40;;;;;;;76729;;-1:-1:-1;76758:11:0;;;;;;;76729:40;:66;;;;-1:-1:-1;76787:8:0;;;;76786:9;76729:66;:100;;;;-1:-1:-1;27896:6:0;;-1:-1:-1;;;;;76812:17:0;;;27896:6;;76812:17;;76729:100;:151;;;;-1:-1:-1;;;;;;76847:33:0;;;;;;:25;:33;;;;;;;;76846:34;76729:151;76711:1101;;;76907:8;:15;;-1:-1:-1;;76907:15:0;76918:4;76907:15;;;76986:8;;76907;;76961:43;;77000:3;;76961:34;;:20;;:24;:34::i;:43::-;77038:12;;76939:65;;-1:-1:-1;77021:43:0;;-1:-1:-1;;;;;77038:12:0;76939:65;77021:16;:43::i;:::-;77081:25;77109:73;77178:3;77109:50;77148:10;;77109:20;:38;;:50;;;;:::i;:73::-;77081:101;;77199:27;77229:70;77281:3;77229:29;77251:6;;77229:17;:21;;:29;;;;:::i;:70::-;77333:16;;77199:100;;-1:-1:-1;77316:55:0;;-1:-1:-1;;;;;77333:16:0;77199:100;77316:16;:55::i;:::-;77452:16;;77386:158;;77428:4;;-1:-1:-1;;;;;77452:16:0;77487:42;:17;77509:19;77487:21;:42::i;:::-;77386:15;:158::i;:::-;77561:18;77582:83;77647:3;77582:42;77607:16;;77582:20;:24;;:42;;;;:::i;:83::-;77561:104;;77682:26;77697:10;77682:14;:26::i;:::-;77760:4;34625:7;34657:18;;;;;;;;;;;77725:42;;:16;:42::i;:::-;-1:-1:-1;;77784:8:0;:16;;-1:-1:-1;;77784:16:0;;;-1:-1:-1;;76711:1101:0;77822:49;77838:6;77854:4;77861:9;77822:15;:49::i;:::-;77882:17;;:42;;-1:-1:-1;;;77882:42:0;;-1:-1:-1;;;;;77882:17:0;;;;:28;;:42;;77911:6;;77919:4;;77882:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75810:2122;;;;75753:2179;:::o;71849:110::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;71928:16:::1;:23:::0;;-1:-1:-1;;;;;;71928:23:0::1;-1:-1:-1::0;;;;;71928:23:0;;;::::1;::::0;;;::::1;::::0;;71849:110::o;33454:104::-;33510:13;33543:7;33536:14;;;;;:::i;72697:313::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;72833:13:::1;::::0;-1:-1:-1;;;;;72825:21:0;;::::1;72833:13:::0;::::1;72825:21;;72803:145;;;::::0;-1:-1:-1;;;72803:145:0;;17205:2:1;72803:145:0::1;::::0;::::1;17187:21:1::0;17244:2;17224:18;;;17217:30;17283:34;17263:18;;;17256:62;17354:34;17334:18;;;17327:62;-1:-1:-1;;;17405:19:1;;;17398:41;17456:19;;72803:145:0::1;17003:478:1::0;72803:145:0::1;72961:41;72990:4;72996:5;72961:28;:41::i;81594:121::-:0;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;81664:17:::1;::::0;:43:::1;::::0;-1:-1:-1;;;81664:43:0;;::::1;::::0;::::1;22475:25:1::0;;;-1:-1:-1;;;;;81664:17:0;;::::1;::::0;:34:::1;::::0;22448:18:1;;81664:43:0::1;22329:177:1::0;84274:125:0;84354:17;;:37;;;-1:-1:-1;;;84354:37:0;;;;84327:7;;-1:-1:-1;;;;;84354:17:0;;:35;;:37;;;;;;;;;;;;;;:17;:37;;;;;;;;;;37817:388;37925:4;37947:228;27168:10;37997:7;38019:145;38076:15;38019:145;;;;;;;;;;;;;;;;;27168:10;38019:25;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;38019:34:0;;;;;;;;;;;;:38;:145::i;81213:109::-;81285:17;;:29;;;-1:-1:-1;;;81285:29:0;;;;81258:7;;-1:-1:-1;;;;;81285:17:0;;:27;;:29;;;;;;;;;;;;;;:17;:29;;;;;;;;;;34896:200;35002:4;35024:42;27168:10;35048:9;35059:6;35024:9;:42::i;80557:180::-;28043:6;;80652:7;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;80684:17:::1;::::0;:45:::1;::::0;-1:-1:-1;;;80684:45:0;;-1:-1:-1;;;;;6434:32:1;;;80684:45:0::1;::::0;::::1;6416:51:1::0;80684:17:0;;::::1;::::0;:36:::1;::::0;6389:18:1;;80684:45:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;82809:331::-:0;82858:13;27168:10;82884:59;;;;-1:-1:-1;;;82884:59:0;;;;;;;:::i;:::-;82976:17;;-1:-1:-1;;;;;82976:17:0;:30;27168:10;82976:44;;-1:-1:-1;;;;;;82976:44:0;;;;;;;-1:-1:-1;;;;;6434:32:1;;;82976:44:0;;;6416:51:1;6389:18;;82976:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;82954:107;;;;-1:-1:-1;;;82954:107:0;;;;;;;:::i;:::-;83079:17;;-1:-1:-1;;;;;83079:17:0;:39;27168:10;83119:12;27088:98;81840:120;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;81908:17:::1;::::0;:44:::1;::::0;-1:-1:-1;;;81908:44:0;;8452:14:1;;8445:22;81908:44:0::1;::::0;::::1;8427:41:1::0;-1:-1:-1;;;;;81908:17:0;;::::1;::::0;:35:::1;::::0;8400:18:1;;81908:44:0::1;8287:187:1::0;73018:141:0;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;73120:23:0;;;::::1;;::::0;;;:14:::1;:23;::::0;;;;:31;;-1:-1:-1;;73120:31:0::1;::::0;::::1;;::::0;;;::::1;::::0;;73018:141::o;82349:123::-;82423:17;;:41;;;-1:-1:-1;;;82423:41:0;;;;82396:7;;-1:-1:-1;;;;;82423:17:0;;:39;;:41;;;;;;;;;;;;;;:17;:41;;;;;;;;;;81469:117;81545:17;;:33;;;-1:-1:-1;;;81545:33:0;;;;81518:7;;-1:-1:-1;;;;;81545:17:0;;:31;;:33;;;;;;;;;;;;;;:17;:33;;;;;;;;;;83489:334;83540:13;27168:10;83566:59;;;;-1:-1:-1;;;83566:59:0;;;;;;;:::i;:::-;83658:17;;-1:-1:-1;;;;;83658:17:0;:30;27168:10;83658:44;;-1:-1:-1;;;;;;83658:44:0;;;;;;;-1:-1:-1;;;;;6434:32:1;;;83658:44:0;;;6416:51:1;6389:18;;83658:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83636:107;;;;-1:-1:-1;;;83636:107:0;;;;;;;:::i;:::-;83761:17;;-1:-1:-1;;;;;83761:17:0;:40;27168:10;83802:12;27088:98;28776:281;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;28879:22:0;::::1;28857:110;;;::::0;-1:-1:-1;;;28857:110:0;;10898:2:1;28857:110:0::1;::::0;::::1;10880:21:1::0;10937:2;10917:18;;;10910:30;10976:34;10956:18;;;10949:62;-1:-1:-1;;;11027:18:1;;;11020:36;11073:19;;28857:110:0::1;10696:402:1::0;28857:110:0::1;29004:6;::::0;28983:38:::1;::::0;-1:-1:-1;;;;;28983:38:0;;::::1;::::0;29004:6:::1;::::0;28983:38:::1;::::0;29004:6:::1;::::0;28983:38:::1;29032:6;:17:::0;;-1:-1:-1;;;;;;29032:17:0::1;-1:-1:-1::0;;;;;29032:17:0;;;::::1;::::0;;;::::1;::::0;;28776:281::o;81723:109::-;81795:17;;:29;;;-1:-1:-1;;;81795:29:0;;;;81768:7;;-1:-1:-1;;;;;81795:17:0;;:27;;:29;;;;;;;;;;;;;;:17;:29;;;;;;;;;;80408:141;80498:17;;:43;;-1:-1:-1;;;80498:43:0;;-1:-1:-1;;;;;6434:32:1;;;80498:43:0;;;6416:51:1;80471:7:0;;80498:17;;:34;;6389:18:1;;80498:43:0;6270:203:1;82223:118:0;82295:17;;:38;;;-1:-1:-1;;;82295:38:0;;;;82268:7;;-1:-1:-1;;;;;82295:17:0;;:36;;:38;;;;;;;;;;;;;;:17;:38;;;;;;;;;;81968:108;82038:17;;:30;;;-1:-1:-1;;;82038:30:0;;;;82014:4;;-1:-1:-1;;;;;82038:17:0;;:28;;:30;;;;;;;;;;;;;;:17;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;70976:145::-;28043:6;;-1:-1:-1;;;;;28043:6:0;27168:10;28043:22;28035:67;;;;-1:-1:-1;;;28035:67:0;;;;;;;:::i;:::-;71057:17:::1;:56:::0;;-1:-1:-1;;;;;;71057:56:0::1;-1:-1:-1::0;;;;;71057:56:0;;;::::1;::::0;;;::::1;::::0;;70976:145::o;2900:181::-;2958:7;;2990:5;2994:1;2990;:5;:::i;:::-;2978:17;;3019:1;3014;:6;;3006:46;;;;-1:-1:-1;;;3006:46:0;;11708:2:1;3006:46:0;;;11690:21:1;11747:2;11727:18;;;11720:30;11786:29;11766:18;;;11759:57;11833:18;;3006:46:0;11506:351:1;41196:380:0;-1:-1:-1;;;;;41332:19:0;;41324:68;;;;-1:-1:-1;;;41324:68:0;;20524:2:1;41324:68:0;;;20506:21:1;20563:2;20543:18;;;20536:30;20602:34;20582:18;;;20575:62;-1:-1:-1;;;20653:18:1;;;20646:34;20697:19;;41324:68:0;20322:400:1;41324:68:0;-1:-1:-1;;;;;41411:21:0;;41403:68;;;;-1:-1:-1;;;41403:68:0;;11305:2:1;41403:68:0;;;11287:21:1;11344:2;11324:18;;;11317:30;11383:34;11363:18;;;11356:62;-1:-1:-1;;;11434:18:1;;;11427:32;11476:19;;41403:68:0;11103:398:1;41403:68:0;-1:-1:-1;;;;;41484:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;41536:32;;22475:25:1;;;41536:32:0;;22448:18:1;41536:32:0;;;;;;;;41196:380;;;:::o;53423:257::-;53642:12;;-1:-1:-1;;;;;53622:16:0;;53569:7;53622:16;;;:7;:16;;;;;;53569:7;;53657:15;;53606:32;;:13;:32;:::i;:::-;53605:49;;;;:::i;:::-;:67;;;;:::i;:::-;53589:83;53423:257;-1:-1:-1;;;;53423:257:0:o;11099:391::-;11228:6;11203:21;:31;;11181:110;;;;-1:-1:-1;;;11181:110:0;;14068:2:1;11181:110:0;;;14050:21:1;14107:2;14087:18;;;14080:30;14146:31;14126:18;;;14119:59;14195:18;;11181:110:0;13866:353:1;11181:110:0;11305:12;11323:9;-1:-1:-1;;;;;11323:14:0;11345:6;11323:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11304:52;;;11389:7;11367:115;;;;-1:-1:-1;;;11367:115:0;;13226:2:1;11367:115:0;;;13208:21:1;13265:2;13245:18;;;13238:30;13304:34;13284:18;;;13277:62;13375:28;13355:18;;;13348:56;13421:19;;11367:115:0;13024:422:1;73525:445:0;-1:-1:-1;;;;;73657:18:0;;73649:68;;;;-1:-1:-1;;;73649:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;73736:16:0;;73728:64;;;;-1:-1:-1;;;73728:64:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;73826:20:0;;;;;;:14;:20;;;;;;;;73825:21;:44;;;;-1:-1:-1;;;;;;73851:18:0;;;;;;:14;:18;;;;;;;;73850:19;73825:44;73803:113;;;;-1:-1:-1;;;73803:113:0;;16857:2:1;73803:113:0;;;16839:21:1;16896:2;16876:18;;;16869:30;-1:-1:-1;;;16915:18:1;;;16908:49;16974:18;;73803:113:0;16655:343:1;73803:113:0;73929:33;73945:4;73951:2;73955:6;73929:15;:33::i;3803:226::-;3923:7;3959:12;3951:6;;;;3943:29;;;;-1:-1:-1;;;3943:29:0;;;;;;;;:::i;:::-;-1:-1:-1;3983:9:0;3995:5;3999:1;3995;:5;:::i;:::-;3983:17;3803:226;-1:-1:-1;;;;;3803:226:0:o;42911:248::-;43082:58;;;-1:-1:-1;;;;;6678:32:1;;43082:58:0;;;6660:51:1;6727:18;;;;6720:34;;;43082:58:0;;;;;;;;;;6633:18:1;;;;43082:58:0;;;;;;;;-1:-1:-1;;;;;43082:58:0;-1:-1:-1;;;43082:58:0;;;43028:123;;43062:5;;43028:19;:123::i;4288:471::-;4346:7;4591:6;4587:47;;-1:-1:-1;4621:1:0;4614:8;;4587:47;4646:9;4658:5;4662:1;4658;:5;:::i;:::-;4646:17;-1:-1:-1;4691:1:0;4682:5;4686:1;4646:17;4682:5;:::i;:::-;:10;4674:56;;;;-1:-1:-1;;;4674:56:0;;19355:2:1;4674:56:0;;;19337:21:1;19394:2;19374:18;;;19367:30;19433:34;19413:18;;;19406:62;-1:-1:-1;;;19484:18:1;;;19477:31;19525:19;;4674:56:0;19153:397:1;5235:132:0;5293:7;5320:39;5324:1;5327;5320:39;;;;;;;;;;;;;;;;;:3;:39::i;73978:304::-;74088:21;74120:24;74137:6;74120:16;:24::i;:::-;74155:18;74176:46;74177:21;74204:17;74176:27;:46::i;:::-;74233:41;;74155:67;;-1:-1:-1;;;;;;74233:29:0;;;:41;;;;;74155:67;;74233:41;;;;74155:67;74233:29;:41;;;;;;;;;;;;;;;;;;;38695:610;-1:-1:-1;;;;;38835:20:0;;38827:70;;;;-1:-1:-1;;;38827:70:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;38916:23:0;;38908:71;;;;-1:-1:-1;;;38908:71:0;;;;;;;:::i;:::-;39072:108;39108:6;39072:108;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;39072:17:0;;:9;:17;;;;;;;;;;;;:108;:21;:108::i;:::-;-1:-1:-1;;;;;39052:17:0;;;:9;:17;;;;;;;;;;;:128;;;;39214:20;;;;;;;:32;;39239:6;39214:24;:32::i;:::-;-1:-1:-1;;;;;39191:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;39262:35;22475:25:1;;;39191:20:0;;39262:35;;;;;;22448:18:1;39262:35:0;22329:177:1;3364:136:0;3422:7;3449:43;3453:1;3456;3449:43;;;;;;;;;;;;;;;;;:3;:43::i;74290:420::-;74349:12;74364:13;:6;74375:1;74364:10;:13::i;:::-;74349:28;-1:-1:-1;74388:17:0;74408:16;:6;74349:28;74408:10;:16::i;:::-;74388:36;-1:-1:-1;74462:21:0;74496:22;74513:4;74496:16;:22::i;:::-;74531:18;74552:41;:21;74578:14;74552:25;:41::i;:::-;74531:62;;74606:35;74619:9;74630:10;74606:12;:35::i;:::-;74659:43;;;23698:25:1;;;23754:2;23739:18;;23732:34;;;23782:18;;;23775:34;;;74659:43:0;;23686:2:1;23671:18;74659:43:0;;;;;;;74338:372;;;;74290:420;:::o;74718:503::-;74808:16;;;74822:1;74808:16;;;;;;;;74784:21;;74808:16;;;;;;;;;;-1:-1:-1;74808:16:0;74784:40;;74853:4;74835;74840:1;74835:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;74835:23:0;;;:7;;;;;;;;;;:23;;;;74879:15;;:22;;;-1:-1:-1;;;74879:22:0;;;;:15;;;;;:20;;:22;;;;;74835:7;;74879:22;;;;;:15;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;74869:4;74874:1;74869:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;74869:32:0;;;:7;;;;;;;;;:32;74946:15;;74914:62;;74931:4;;74946:15;74964:11;74914:8;:62::i;:::-;74989:15;;:224;;-1:-1:-1;;;74989:224:0;;-1:-1:-1;;;;;74989:15:0;;;;:66;;:224;;75070:11;;74989:15;;75140:4;;75167;;75187:15;;74989:224;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74773:448;74718:503;:::o;73167:350::-;-1:-1:-1;;;;;73272:31:0;;;;;;:25;:31;;;;;;;;:40;;;;;;;73250:151;;;;-1:-1:-1;;;73250:151:0;;16427:2:1;73250:151:0;;;16409:21:1;16466:2;16446:18;;;16439:30;16505:34;16485:18;;;16478:62;16576:31;16556:18;;;16549:59;16625:19;;73250:151:0;16225:425:1;73250:151:0;-1:-1:-1;;;;;73412:31:0;;;;;;:25;:31;;;;;;:39;;-1:-1:-1;;73412:39:0;;;;;;;;;;73469:40;;73412:39;;:31;73469:40;;;73167:350;;:::o;45826:802::-;46250:23;46276:106;46318:4;46276:106;;;;;;;;;;;;;;;;;46284:5;-1:-1:-1;;;;;46276:27:0;;;:106;;;;;:::i;:::-;46397:17;;46250:132;;-1:-1:-1;46397:21:0;46393:228;;46512:10;46501:30;;;;;;;;;;;;:::i;:::-;46475:134;;;;-1:-1:-1;;;46475:134:0;;21287:2:1;46475:134:0;;;21269:21:1;21326:2;21306:18;;;21299:30;21365:34;21345:18;;;21338:62;-1:-1:-1;;;21416:18:1;;;21409:40;21466:19;;46475:134:0;21085:406:1;5863:312:0;5983:7;6018:12;6011:5;6003:28;;;;-1:-1:-1;;;6003:28:0;;;;;;;;:::i;:::-;-1:-1:-1;6042:9:0;6054:5;6058:1;6054;:5;:::i;75229:516::-;75409:15;;75377:62;;75394:4;;-1:-1:-1;;;;;75409:15:0;75427:11;75377:8;:62::i;:::-;75482:15;;:255;;-1:-1:-1;;;75482:255:0;;75554:4;75482:255;;;8016:34:1;8066:18;;;8059:34;;;75482:15:0;8109:18:1;;;8102:34;;;8152:18;;;8145:34;;;8195:19;;;8188:44;75711:15:0;8248:19:1;;;8241:35;-1:-1:-1;;;;;75482:15:0;;;;:31;;75521:9;;7950:19:1;;75482:255:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;12513:229::-;12650:12;12682:52;12704:6;12712:4;12718:1;12721:12;12650;10262:20;;14029:60;;;;-1:-1:-1;;;14029:60:0;;20929:2:1;14029:60:0;;;20911:21:1;20968:2;20948:18;;;20941:30;21007:31;20987:18;;;20980:59;21056:18;;14029:60:0;20727:353:1;14029:60:0;14103:12;14117:23;14144:6;-1:-1:-1;;;;;14144:11:0;14163:5;14184:4;14144:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14102:97;;;;14217:51;14234:7;14243:10;14255:12;14217:16;:51::i;:::-;14210:58;13705:571;-1:-1:-1;;;;;;;13705:571:0:o;16605:712::-;16755:12;16784:7;16780:530;;;-1:-1:-1;16815:10:0;16808:17;;16780:530;16929:17;;:21;16925:374;;17127:10;17121:17;17188:15;17175:10;17171:2;17167:19;17160:44;16925:374;17270:12;17263:20;;-1:-1:-1;;;17263:20:0;;;;;;;;:::i;14:247:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;181:9;168:23;200:31;225:5;200:31;:::i;266:251::-;336:6;389:2;377:9;368:7;364:23;360:32;357:52;;;405:1;402;395:12;357:52;437:9;431:16;456:31;481:5;456:31;:::i;782:388::-;850:6;858;911:2;899:9;890:7;886:23;882:32;879:52;;;927:1;924;917:12;879:52;966:9;953:23;985:31;1010:5;985:31;:::i;:::-;1035:5;-1:-1:-1;1092:2:1;1077:18;;1064:32;1105:33;1064:32;1105:33;:::i;:::-;1157:7;1147:17;;;782:388;;;;;:::o;1175:456::-;1252:6;1260;1268;1321:2;1309:9;1300:7;1296:23;1292:32;1289:52;;;1337:1;1334;1327:12;1289:52;1376:9;1363:23;1395:31;1420:5;1395:31;:::i;:::-;1445:5;-1:-1:-1;1502:2:1;1487:18;;1474:32;1515:33;1474:32;1515:33;:::i;:::-;1175:456;;1567:7;;-1:-1:-1;;;1621:2:1;1606:18;;;;1593:32;;1175:456::o;1636:382::-;1701:6;1709;1762:2;1750:9;1741:7;1737:23;1733:32;1730:52;;;1778:1;1775;1768:12;1730:52;1817:9;1804:23;1836:31;1861:5;1836:31;:::i;:::-;1886:5;-1:-1:-1;1943:2:1;1928:18;;1915:32;1956:30;1915:32;1956:30;:::i;2023:315::-;2091:6;2099;2152:2;2140:9;2131:7;2127:23;2123:32;2120:52;;;2168:1;2165;2158:12;2120:52;2207:9;2194:23;2226:31;2251:5;2226:31;:::i;:::-;2276:5;2328:2;2313:18;;;;2300:32;;-1:-1:-1;;;2023:315:1:o;2343:241::-;2399:6;2452:2;2440:9;2431:7;2427:23;2423:32;2420:52;;;2468:1;2465;2458:12;2420:52;2507:9;2494:23;2526:28;2548:5;2526:28;:::i;2589:245::-;2656:6;2709:2;2697:9;2688:7;2684:23;2680:32;2677:52;;;2725:1;2722;2715:12;2677:52;2757:9;2751:16;2776:28;2798:5;2776:28;:::i;3514:673::-;3583:6;3636:2;3624:9;3615:7;3611:23;3607:32;3604:52;;;3652:1;3649;3642:12;3604:52;3692:9;3679:23;3725:18;3717:6;3714:30;3711:50;;;3757:1;3754;3747:12;3711:50;3780:22;;3833:4;3825:13;;3821:27;-1:-1:-1;3811:55:1;;3862:1;3859;3852:12;3811:55;3898:2;3885:16;3923:49;3939:32;3968:2;3939:32;:::i;:::-;3923:49;:::i;:::-;3995:2;3988:5;3981:17;4035:7;4030:2;4025;4021;4017:11;4013:20;4010:33;4007:53;;;4056:1;4053;4046:12;4007:53;4111:2;4106;4102;4098:11;4093:2;4086:5;4082:14;4069:45;4155:1;4134:14;;;4150:2;4130:23;4123:34;;;;4138:5;3514:673;-1:-1:-1;;;;3514:673:1:o;4192:636::-;4272:6;4325:2;4313:9;4304:7;4300:23;4296:32;4293:52;;;4341:1;4338;4331:12;4293:52;4374:9;4368:16;4407:18;4399:6;4396:30;4393:50;;;4439:1;4436;4429:12;4393:50;4462:22;;4515:4;4507:13;;4503:27;-1:-1:-1;4493:55:1;;4544:1;4541;4534:12;4493:55;4573:2;4567:9;4598:49;4614:32;4643:2;4614:32;:::i;4598:49::-;4670:2;4663:5;4656:17;4710:7;4705:2;4700;4696;4692:11;4688:20;4685:33;4682:53;;;4731:1;4728;4721:12;4682:53;4744:54;4795:2;4790;4783:5;4779:14;4774:2;4770;4766:11;4744:54;:::i;4833:180::-;4892:6;4945:2;4933:9;4924:7;4920:23;4916:32;4913:52;;;4961:1;4958;4951:12;4913:52;-1:-1:-1;4984:23:1;;4833:180;-1:-1:-1;4833:180:1:o;5018:184::-;5088:6;5141:2;5129:9;5120:7;5116:23;5112:32;5109:52;;;5157:1;5154;5147:12;5109:52;-1:-1:-1;5180:16:1;;5018:184;-1:-1:-1;5018:184:1:o;5207:306::-;5295:6;5303;5311;5364:2;5352:9;5343:7;5339:23;5335:32;5332:52;;;5380:1;5377;5370:12;5332:52;5409:9;5403:16;5393:26;;5459:2;5448:9;5444:18;5438:25;5428:35;;5503:2;5492:9;5488:18;5482:25;5472:35;;5207:306;;;;;:::o;5518:258::-;5560:3;5598:5;5592:12;5625:6;5620:3;5613:19;5641:63;5697:6;5690:4;5685:3;5681:14;5674:4;5667:5;5663:16;5641:63;:::i;:::-;5758:2;5737:15;-1:-1:-1;;5733:29:1;5724:39;;;;5765:4;5720:50;;5518:258;-1:-1:-1;;5518:258:1:o;5781:274::-;5910:3;5948:6;5942:13;5964:53;6010:6;6005:3;5998:4;5990:6;5986:17;5964:53;:::i;:::-;6033:16;;;;;5781:274;-1:-1:-1;;5781:274:1:o;7074:317::-;-1:-1:-1;;;;;7251:32:1;;7233:51;;7320:2;7315;7300:18;;7293:30;;;-1:-1:-1;;7340:45:1;;7366:18;;7358:6;7340:45;:::i;8945:220::-;9094:2;9083:9;9076:21;9057:4;9114:45;9155:2;9144:9;9140:18;9132:6;9114:45;:::i;9589:399::-;9791:2;9773:21;;;9830:2;9810:18;;;9803:30;9869:34;9864:2;9849:18;;9842:62;-1:-1:-1;;;9935:2:1;9920:18;;9913:33;9978:3;9963:19;;9589:399::o;9993:337::-;10195:2;10177:21;;;10234:2;10214:18;;;10207:30;-1:-1:-1;;;10268:2:1;10253:18;;10246:43;10321:2;10306:18;;9993:337::o;12268:344::-;12470:2;12452:21;;;12509:2;12489:18;;;12482:30;-1:-1:-1;;;12543:2:1;12528:18;;12521:50;12603:2;12588:18;;12268:344::o;12617:402::-;12819:2;12801:21;;;12858:2;12838:18;;;12831:30;12897:34;12892:2;12877:18;;12870:62;-1:-1:-1;;;12963:2:1;12948:18;;12941:36;13009:3;12994:19;;12617:402::o;14631:407::-;14833:2;14815:21;;;14872:2;14852:18;;;14845:30;14911:34;14906:2;14891:18;;14884:62;-1:-1:-1;;;14977:2:1;14962:18;;14955:41;15028:3;15013:19;;14631:407::o;19555:356::-;19757:2;19739:21;;;19776:18;;;19769:30;19835:34;19830:2;19815:18;;19808:62;19902:2;19887:18;;19555:356::o;19916:401::-;20118:2;20100:21;;;20157:2;20137:18;;;20130:30;20196:34;20191:2;20176:18;;20169:62;-1:-1:-1;;;20262:2:1;20247:18;;20240:35;20307:3;20292:19;;19916:401::o;22511:980::-;22773:4;22821:3;22810:9;22806:19;22852:6;22841:9;22834:25;22878:2;22916:6;22911:2;22900:9;22896:18;22889:34;22959:3;22954:2;22943:9;22939:18;22932:31;22983:6;23018;23012:13;23049:6;23041;23034:22;23087:3;23076:9;23072:19;23065:26;;23126:2;23118:6;23114:15;23100:29;;23147:1;23157:195;23171:6;23168:1;23165:13;23157:195;;;23236:13;;-1:-1:-1;;;;;23232:39:1;23220:52;;23327:15;;;;23292:12;;;;23268:1;23186:9;23157:195;;;-1:-1:-1;;;;;;;23408:32:1;;;;23403:2;23388:18;;23381:60;-1:-1:-1;;;23472:3:1;23457:19;23450:35;23369:3;22511:980;-1:-1:-1;;;22511:980:1:o;24009:275::-;24080:2;24074:9;24145:2;24126:13;;-1:-1:-1;;24122:27:1;24110:40;;24180:18;24165:34;;24201:22;;;24162:62;24159:88;;;24227:18;;:::i;:::-;24263:2;24256:22;24009:275;;-1:-1:-1;24009:275:1:o;24289:187::-;24338:4;24371:18;24363:6;24360:30;24357:56;;;24393:18;;:::i;:::-;-1:-1:-1;24459:2:1;24438:15;-1:-1:-1;;24434:29:1;24465:4;24430:40;;24289:187::o;24481:128::-;24521:3;24552:1;24548:6;24545:1;24542:13;24539:39;;;24558:18;;:::i;:::-;-1:-1:-1;24594:9:1;;24481:128::o;24614:217::-;24654:1;24680;24670:132;;24724:10;24719:3;24715:20;24712:1;24705:31;24759:4;24756:1;24749:15;24787:4;24784:1;24777:15;24670:132;-1:-1:-1;24816:9:1;;24614:217::o;24836:168::-;24876:7;24942:1;24938;24934:6;24930:14;24927:1;24924:21;24919:1;24912:9;24905:17;24901:45;24898:71;;;24949:18;;:::i;:::-;-1:-1:-1;24989:9:1;;24836:168::o;25009:125::-;25049:4;25077:1;25074;25071:8;25068:34;;;25082:18;;:::i;:::-;-1:-1:-1;25119:9:1;;25009:125::o;25139:258::-;25211:1;25221:113;25235:6;25232:1;25229:13;25221:113;;;25311:11;;;25305:18;25292:11;;;25285:39;25257:2;25250:10;25221:113;;;25352:6;25349:1;25346:13;25343:48;;;-1:-1:-1;;25387:1:1;25369:16;;25362:27;25139:258::o;25402:380::-;25481:1;25477:12;;;;25524;;;25545:61;;25599:4;25591:6;25587:17;25577:27;;25545:61;25652:2;25644:6;25641:14;25621:18;25618:38;25615:161;;;25698:10;25693:3;25689:20;25686:1;25679:31;25733:4;25730:1;25723:15;25761:4;25758:1;25751:15;25615:161;;25402:380;;;:::o;25787:127::-;25848:10;25843:3;25839:20;25836:1;25829:31;25879:4;25876:1;25869:15;25903:4;25900:1;25893:15;25919:127;25980:10;25975:3;25971:20;25968:1;25961:31;26011:4;26008:1;26001:15;26035:4;26032:1;26025:15;26051:127;26112:10;26107:3;26103:20;26100:1;26093:31;26143:4;26140:1;26133:15;26167:4;26164:1;26157:15;26183:131;-1:-1:-1;;;;;26258:31:1;;26248:42;;26238:70;;26304:1;26301;26294:12;26238:70;26183:131;:::o;26319:118::-;26405:5;26398:13;26391:21;26384:5;26381:32;26371:60;;26427:1;26424;26417:12

Swarm Source

ipfs://51e2ad66d1ffe55bab9c6dc5f769e69bbca32333194427e3754d91f95cb12089
Loading