Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function _values(Set storage set)
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function values(Bytes32Set storage se ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function values(AddressSet storage se ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•    - function values(UintSet storage set)
• library Counters
•    - function current(Counter storage coun ...
•    - function increment(Counter storage co ...
•    - function decrement(Counter storage co ...
•    - function reset(Counter storage counte ...
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
• library Arrays
•    - function findUpperBound(uint256[] sto ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _setOwner(address newOwner)
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•  contract ERC20 is Context, IERC20, ...
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
•    - function _snapshot()
•    - function _getCurrentSnapshotId()
•    - function balanceOfAt(address account, ...
•    - function totalSupplyAt(uint256 snapsh ...
•    - function _beforeTokenTransfer(
•    - function _valueAt(uint256 snapshotId, ...
•    - function _updateAccountSnapshot(addre ...
•    - function _updateTotalSupplySnapshot()
•    - function _updateSnapshot(Snapshots st ...
•    - function _lastSnapshotId(uint256[] st ...
• interface IUniswapV2Router02
•    - function addLiquidityETH(
•    - function swapExactTokensForETHSupport ...
•  contract JPEGvaultDAOToken is ERC2 ... *
•    - function transfer(address recipient, ...
•    - function swapAndLiquify()
•    - function createRedistribution()
•    - function calcSupplyHolders()
•    - function setDevFees(uint _fees)
•    - function setVaultFees(uint _fees)
•    - function setLiquidityFees(uint _fees)
•    - function setMinAmountForSwap(uint _am ...
•    - function setWETHAddress(address _addr ...
•    - function setDevAddress(address _addre ...
•    - function setVaultAddress(address _add ...
•    - function setRedistributionContract(ad ...
•    - function setUniswapV2Pair(address _pa ...
•    - function excludeTaxAddress(address _a ...
•    - function excludedRedistributionAddres ...
•    - function removeTaxAddress(address _ad ...
•    - function removeRedistributionAddress( ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// File: @openzeppelin/contracts/utils/math/SafeMath.sol



pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

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

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

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

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

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

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

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

// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol



pragma solidity ^0.8.0;

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

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

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

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

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

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

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

// File: @openzeppelin/contracts/utils/Counters.sol



pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol



pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }
}

// File: @openzeppelin/contracts/utils/Arrays.sol



pragma solidity ^0.8.0;


/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (array[mid] > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && array[low - 1] == element) {
            return low - 1;
        } else {
            return low;
        }
    }
}

// File: @openzeppelin/contracts/utils/Context.sol



pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/access/Ownable.sol



pragma solidity ^0.8.0;


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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

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

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

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

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol



pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol



pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol



pragma solidity ^0.8.0;




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

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        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] + 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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This 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);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(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 += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

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

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(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 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 {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol



pragma solidity ^0.8.0;




/**
 * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and
 * total supply at the time are recorded for later access.
 *
 * This can be used to safely create mechanisms based on token balances such as trustless dividends or weighted voting.
 * In naive implementations it's possible to perform a "double spend" attack by reusing the same balance from different
 * accounts. By using snapshots to calculate dividends or voting power, those attacks no longer apply. It can also be
 * used to create an efficient ERC20 forking mechanism.
 *
 * Snapshots are created by the internal {_snapshot} function, which will emit the {Snapshot} event and return a
 * snapshot id. To get the total supply at the time of a snapshot, call the function {totalSupplyAt} with the snapshot
 * id. To get the balance of an account at the time of a snapshot, call the {balanceOfAt} function with the snapshot id
 * and the account address.
 *
 * NOTE: Snapshot policy can be customized by overriding the {_getCurrentSnapshotId} method. For example, having it
 * return `block.number` will trigger the creation of snapshot at the begining of each new block. When overridding this
 * function, be careful about the monotonicity of its result. Non-monotonic snapshot ids will break the contract.
 *
 * Implementing snapshots for every block using this method will incur significant gas costs. For a gas-efficient
 * alternative consider {ERC20Votes}.
 *
 * ==== Gas Costs
 *
 * Snapshots are efficient. Snapshot creation is _O(1)_. Retrieval of balances or total supply from a snapshot is _O(log
 * n)_ in the number of snapshots that have been created, although _n_ for a specific account will generally be much
 * smaller since identical balances in subsequent snapshots are stored as a single entry.
 *
 * There is a constant overhead for normal ERC20 transfers due to the additional snapshot bookkeeping. This overhead is
 * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent
 * transfers will have normal cost until the next snapshot, and so on.
 */

abstract contract ERC20Snapshot is ERC20 {
    // Inspired by Jordi Baylina's MiniMeToken to record historical balances:
    // https://github.com/Giveth/minimd/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol

    using Arrays for uint256[];
    using Counters for Counters.Counter;

    // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
    // Snapshot struct, but that would impede usage of functions that work on an array.
    struct Snapshots {
        uint256[] ids;
        uint256[] values;
    }

    mapping(address => Snapshots) private _accountBalanceSnapshots;
    Snapshots private _totalSupplySnapshots;

    // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
    Counters.Counter private _currentSnapshotId;

    /**
     * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created.
     */
    event Snapshot(uint256 id);

    /**
     * @dev Creates a new snapshot and returns its snapshot id.
     *
     * Emits a {Snapshot} event that contains the same id.
     *
     * {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
     * set of accounts, for example using {AccessControl}, or it may be open to the public.
     *
     * [WARNING]
     * ====
     * While an open way of calling {_snapshot} is required for certain trust minimization mechanisms such as forking,
     * you must consider that it can potentially be used by attackers in two ways.
     *
     * First, it can be used to increase the cost of retrieval of values from snapshots, although it will grow
     * logarithmically thus rendering this attack ineffective in the long term. Second, it can be used to target
     * specific accounts and increase the cost of ERC20 transfers for them, in the ways specified in the Gas Costs
     * section above.
     *
     * We haven't measured the actual numbers; if this is something you're interested in please reach out to us.
     * ====
     */
    function _snapshot() internal virtual returns (uint256) {
        _currentSnapshotId.increment();

        uint256 currentId = _getCurrentSnapshotId();
        emit Snapshot(currentId);
        return currentId;
    }

    /**
     * @dev Get the current snapshotId
     */
    function _getCurrentSnapshotId() internal view virtual returns (uint256) {
        return _currentSnapshotId.current();
    }

    /**
     * @dev Retrieves the balance of `account` at the time `snapshotId` was created.
     */
    function balanceOfAt(address account, uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);

        return snapshotted ? value : balanceOf(account);
    }

    /**
     * @dev Retrieves the total supply at the time `snapshotId` was created.
     */
    function totalSupplyAt(uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);

        return snapshotted ? value : totalSupply();
    }

    // Update balance and/or total supply snapshots before the values are modified. This is implemented
    // in the _beforeTokenTransfer hook, which is executed for _mint, _burn, and _transfer operations.
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        if (from == address(0)) {
            // mint
            _updateAccountSnapshot(to);
            _updateTotalSupplySnapshot();
        } else if (to == address(0)) {
            // burn
            _updateAccountSnapshot(from);
            _updateTotalSupplySnapshot();
        } else {
            // transfer
            _updateAccountSnapshot(from);
            _updateAccountSnapshot(to);
        }
    }

    function _valueAt(uint256 snapshotId, Snapshots storage snapshots) private view returns (bool, uint256) {
        require(snapshotId > 0, "ERC20Snapshot: id is 0");
        require(snapshotId <= _getCurrentSnapshotId(), "ERC20Snapshot: nonexistent id");

        // When a valid snapshot is queried, there are three possibilities:
        //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
        //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
        //  to this id is the current one.
        //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
        //  requested id, and its value is the one to return.
        //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
        //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
        //  larger than the requested one.
        //
        // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
        // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
        // exactly this.

        uint256 index = snapshots.ids.findUpperBound(snapshotId);

        if (index == snapshots.ids.length) {
            return (false, 0);
        } else {
            return (true, snapshots.values[index]);
        }
    }

    function _updateAccountSnapshot(address account) private {
        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
    }

    function _updateTotalSupplySnapshot() private {
        _updateSnapshot(_totalSupplySnapshots, totalSupply());
    }

    function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
        uint256 currentId = _getCurrentSnapshotId();
        if (_lastSnapshotId(snapshots.ids) < currentId) {
            snapshots.ids.push(currentId);
            snapshots.values.push(currentValue);
        }
    }

    function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
        if (ids.length == 0) {
            return 0;
        } else {
            return ids[ids.length - 1];
        }
    }
}

// File: JPEGVaultToken.sol


pragma solidity ^0.8.0;





interface IUniswapV2Router02 {
    function addLiquidityETH(
      address token,
      uint amountTokenDesired,
      uint amountTokenMin,
      uint amountETHMin,
      address to,
      uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
      uint amountIn,
      uint amountOutMin,
      address[] calldata path,
      address to,
      uint deadline
    ) external;
}

contract JPEGvaultDAOToken is ERC20Snapshot, Ownable {
    using SafeMath for uint;
    using EnumerableSet for EnumerableSet.AddressSet;
    
    EnumerableSet.AddressSet private excludedRedistribution; // exclure de la redistribution
    EnumerableSet.AddressSet private excludedTax; // exclure du paiement des taxes

    IUniswapV2Router02 private m_UniswapV2Router;
    address private uniswapV2Pair;
    address private WETHAddr;
    
    address private devAddress;
    address private vaultAddress;
    address private redistributionContract;
    uint private devFees;
    uint private vaultFees;
    uint private liquidityFees;
    uint private minAmountForSwap;

    constructor(address _vault) ERC20("JPEGvaultDAO", "JPEG") {
        m_UniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        WETHAddr = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; // mainnet change for ropsten if test
        
        devAddress = msg.sender;
        vaultAddress = _vault;
        
        excludedRedistribution.add(address(this));
        excludedRedistribution.add(msg.sender);
        excludedRedistribution.add(vaultAddress);
        excludedRedistribution.add(0xBae21D4247dd3818f720ab4210C095E84e980D96); // dxlock

        excludedTax.add(address(this));
        excludedTax.add(msg.sender);
        excludedTax.add(vaultAddress);
        excludedTax.add(0xBae21D4247dd3818f720ab4210C095E84e980D96); // dxlock

        devFees = 1;
        vaultFees = 7;
        liquidityFees = 2;
        minAmountForSwap = 100;
        _mint(msg.sender, 1000000000 * 10 ** 18);
    }
    
    receive() external payable {}
    
    function transfer(address recipient, uint256 amount) public override returns (bool) {
        require(balanceOf(msg.sender) >= amount, "ERC20: transfer amount exceeds balance");
        
        if (excludedTax.contains(msg.sender)) {
            _transfer(msg.sender, recipient, amount);
            return true;
        } else {
            uint amountDev = amount.mul(devFees).div(100);
            uint amountVault = amount.mul(vaultFees).div(100);
            uint amountLiq = amount.mul(liquidityFees).div(100);
            uint newAmountTransfer = amount.sub(amountDev).sub(amountVault).sub(amountLiq);
            
            _transfer(msg.sender, devAddress, amountDev);
            _transfer(msg.sender, vaultAddress, amountVault);
            _transfer(msg.sender, address(this), amountLiq);
        
            swapAndLiquify();
            
            _transfer(msg.sender, recipient, newAmountTransfer);
            return true;
        }
    }
    
    function swapAndLiquify() private {
        uint balanceInToken = balanceOf(address(this));

        if (balanceInToken >= (minAmountForSwap * 1 ether) && uniswapV2Pair != address(0)) {
            uint amountLiqToken = balanceInToken.div(2);
            uint amountLiqSwapForEth = balanceInToken.sub(amountLiqToken);
            uint balanceInEth = address(this).balance;
            
            // swap token for ETH
            address[] memory _path = new address[](2);
            _path[0] = address(this);
            _path[1] = address(WETHAddr);
            _approve(address(this), address(m_UniswapV2Router), amountLiqSwapForEth);
            m_UniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
                amountLiqSwapForEth,
                0,
                _path,
                address(this),
                block.timestamp
            );
            
            uint ethAmount = address(this).balance.sub(balanceInEth);
            
            // add liquidity with token and ETH
            _approve(address(this), address(m_UniswapV2Router), amountLiqToken);
            m_UniswapV2Router.addLiquidityETH{value: ethAmount}(
                address(this),
                amountLiqToken,
                0,
                0,
                owner(),
                block.timestamp
            );
        }
    }
    
    function createRedistribution() public returns (uint, uint) {
        require(msg.sender == redistributionContract, "Bad caller");

        uint newSnapshotId = _snapshot();

        return (newSnapshotId, calcSupplyHolders());
    }
    
    function calcSupplyHolders() internal view returns (uint) {
        uint balanceExcluded = 0;
        
        for (uint i = 0; i < excludedRedistribution.length(); i++)
            balanceExcluded += balanceOf(excludedRedistribution.at(i));
            
        return totalSupply() - balanceExcluded;
    }
    
    function setDevFees(uint _fees) public onlyOwner {
        devFees = _fees;
    }
    
    function setVaultFees(uint _fees) public onlyOwner {
        vaultFees = _fees;
    }
    
    function setLiquidityFees(uint _fees) public onlyOwner {
        liquidityFees = _fees;
    }
    
    function setMinAmountForSwap(uint _amount) public onlyOwner {
        minAmountForSwap = _amount;
    }
    
    function setWETHAddress(address _address) public onlyOwner {
        WETHAddr = _address;
    }
    
    function setDevAddress(address _address) public onlyOwner {
        devAddress = _address;
        excludedRedistribution.add(_address);
        excludedTax.add(_address);
    }
    
    function setVaultAddress(address _address) public onlyOwner {
        vaultAddress = _address;
        excludedRedistribution.add(_address);
        excludedTax.add(_address);
    }
    
    function setRedistributionContract(address _address) public onlyOwner {
        redistributionContract = _address;
        excludedRedistribution.add(_address);
        excludedTax.add(_address);
    }
    
    function setUniswapV2Pair(address _pair) public onlyOwner {
        uniswapV2Pair = _pair;
        excludedRedistribution.add(_pair);
    }
    
    function excludeTaxAddress(address _address) public onlyOwner {
        excludedTax.add(_address);
    }
    
    function excludedRedistributionAddress(address _address) public onlyOwner {
        excludedRedistribution.add(_address);
    }
    
    function removeTaxAddress(address _address) public onlyOwner {
        excludedTax.remove(_address);
    }
    
    function removeRedistributionAddress(address _address) public onlyOwner {
        excludedRedistribution.remove(_address);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_vault","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":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"createRedistribution","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"excludeTaxAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"excludedRedistributionAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"removeRedistributionAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"removeTaxAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fees","type":"uint256"}],"name":"setDevFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fees","type":"uint256"}],"name":"setLiquidityFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"setMinAmountForSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setRedistributionContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"}],"name":"setUniswapV2Pair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setVaultAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fees","type":"uint256"}],"name":"setVaultFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setWETHAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","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"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000008d3cbfd044f12cceccf067ac92ccba39e8aefc08

-----Decoded View---------------
Arg [0] : _vault (address): 0x8D3CbFD044f12CCeccF067AC92ccBA39e8AEfC08

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000008d3cbfd044f12cceccf067ac92ccba39e8aefc08

51701:6475:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58043:130;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;32307:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34474:169;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33427:108;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35125:492;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33269:93;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36026:215;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57293:205;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56570:95;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47229:266;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57923:108;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56471:87;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56794:97;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55798:239;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;33598:127;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26111:94;;;;;;;;;;;;;:::i;:::-;;57664:106;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57096:185;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;25460:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;32526:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47599:234;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57510:142;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;36744:413;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53400:982;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57782:129;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56376:83;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56903:181;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;34176:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56677:105;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;26360:192;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58043:130;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;58126:39:::1;58156:8;58126:22;:29;;:39;;;;:::i;:::-;;58043:130:::0;:::o;32307:100::-;32361:13;32394:5;32387:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32307:100;:::o;34474:169::-;34557:4;34574:39;34583:12;:10;:12::i;:::-;34597:7;34606:6;34574:8;:39::i;:::-;34631:4;34624:11;;34474:169;;;;:::o;33427:108::-;33488:7;33515:12;;33508:19;;33427:108;:::o;35125:492::-;35265:4;35282:36;35292:6;35300:9;35311:6;35282:9;:36::i;:::-;35331:24;35358:11;:19;35370:6;35358:19;;;;;;;;;;;;;;;:33;35378:12;:10;:12::i;:::-;35358:33;;;;;;;;;;;;;;;;35331:60;;35430:6;35410:16;:26;;35402:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;35517:57;35526:6;35534:12;:10;:12::i;:::-;35567:6;35548:16;:25;35517:8;:57::i;:::-;35605:4;35598:11;;;35125:492;;;;;:::o;33269:93::-;33327:5;33352:2;33345:9;;33269:93;:::o;36026:215::-;36114:4;36131:80;36140:12;:10;:12::i;:::-;36154:7;36200:10;36163:11;:25;36175:12;:10;:12::i;:::-;36163:25;;;;;;;;;;;;;;;:34;36189:7;36163:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;36131:8;:80::i;:::-;36229:4;36222:11;;36026:215;;;;:::o;57293:205::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57399:8:::1;57374:22;;:33;;;;;;;;;;;;;;;;;;57418:36;57445:8;57418:22;:26;;:36;;;;:::i;:::-;;57465:25;57481:8;57465:11;:15;;:25;;;;:::i;:::-;;57293:205:::0;:::o;56570:95::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;56652:5:::1;56636:13;:21;;;;56570:95:::0;:::o;47229:266::-;47316:7;47337:16;47355:13;47372:55;47381:10;47393:24;:33;47418:7;47393:33;;;;;;;;;;;;;;;47372:8;:55::i;:::-;47336:91;;;;47447:11;:40;;47469:18;47479:7;47469:9;:18::i;:::-;47447:40;;;47461:5;47447:40;47440:47;;;;47229:266;;;;:::o;57923:108::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57995:28:::1;58014:8;57995:11;:18;;:28;;;;:::i;:::-;;57923:108:::0;:::o;56471:87::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;56545:5:::1;56533:9;:17;;;;56471:87:::0;:::o;56794:97::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;56875:8:::1;56864;;:19;;;;;;;;;;;;;;;;;;56794:97:::0;:::o;55798:239::-;55846:4;55852;55891:22;;;;;;;;;;;55877:36;;:10;:36;;;55869:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;55941:18;55962:11;:9;:11::i;:::-;55941:32;;55994:13;56009:19;:17;:19::i;:::-;55986:43;;;;;55798:239;;:::o;33598:127::-;33672:7;33699:9;:18;33709:7;33699:18;;;;;;;;;;;;;;;;33692:25;;33598:127;;;:::o;26111:94::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;26176:21:::1;26194:1;26176:9;:21::i;:::-;26111:94::o:0;57664:106::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57737:25:::1;57753:8;57737:11;:15;;:25;;;;:::i;:::-;;57664:106:::0;:::o;57096:185::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57182:8:::1;57167:12;;:23;;;;;;;;;;;;;;;;;;57201:36;57228:8;57201:22;:26;;:36;;;;:::i;:::-;;57248:25;57264:8;57248:11;:15;;:25;;;;:::i;:::-;;57096:185:::0;:::o;25460:87::-;25506:7;25533:6;;;;;;;;;;;25526:13;;25460:87;:::o;32526:104::-;32582:13;32615:7;32608:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32526:104;:::o;47599:234::-;47671:7;47692:16;47710:13;47727:43;47736:10;47748:21;47727:8;:43::i;:::-;47691:79;;;;47790:11;:35;;47812:13;:11;:13::i;:::-;47790:35;;;47804:5;47790:35;47783:42;;;;47599:234;;;:::o;57510:142::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57595:5:::1;57579:13;;:21;;;;;;;;;;;;;;;;;;57611:33;57638:5;57611:22;:26;;:33;;;;:::i;:::-;;57510:142:::0;:::o;36744:413::-;36837:4;36854:24;36881:11;:25;36893:12;:10;:12::i;:::-;36881:25;;;;;;;;;;;;;;;:34;36907:7;36881:34;;;;;;;;;;;;;;;;36854:61;;36954:15;36934:16;:35;;36926:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;37047:67;37056:12;:10;:12::i;:::-;37070:7;37098:15;37079:16;:34;37047:8;:67::i;:::-;37145:4;37138:11;;;36744:413;;;;:::o;53400:982::-;53478:4;53528:6;53503:21;53513:10;53503:9;:21::i;:::-;:31;;53495:82;;;;;;;;;;;;:::i;:::-;;;;;;;;;53602:32;53623:10;53602:11;:20;;:32;;;;:::i;:::-;53598:777;;;53651:40;53661:10;53673:9;53684:6;53651:9;:40::i;:::-;53713:4;53706:11;;;;53598:777;53750:14;53767:28;53791:3;53767:19;53778:7;;53767:6;:10;;:19;;;;:::i;:::-;:23;;:28;;;;:::i;:::-;53750:45;;53810:16;53829:30;53855:3;53829:21;53840:9;;53829:6;:10;;:21;;;;:::i;:::-;:25;;:30;;;;:::i;:::-;53810:49;;53874:14;53891:34;53921:3;53891:25;53902:13;;53891:6;:10;;:25;;;;:::i;:::-;:29;;:34;;;;:::i;:::-;53874:51;;53940:22;53965:53;54008:9;53965:38;53991:11;53965:21;53976:9;53965:6;:10;;:21;;;;:::i;:::-;:25;;:38;;;;:::i;:::-;:42;;:53;;;;:::i;:::-;53940:78;;54047:44;54057:10;54069;;;;;;;;;;;54081:9;54047;:44::i;:::-;54106:48;54116:10;54128:12;;;;;;;;;;;54142:11;54106:9;:48::i;:::-;54169:47;54179:10;54199:4;54206:9;54169;:47::i;:::-;54241:16;:14;:16::i;:::-;54286:51;54296:10;54308:9;54319:17;54286:9;:51::i;:::-;54359:4;54352:11;;;;;;53400:982;;;;;:::o;57782:129::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57867:36:::1;57894:8;57867:22;:26;;:36;;;;:::i;:::-;;57782:129:::0;:::o;56376:83::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;56446:5:::1;56436:7;:15;;;;56376:83:::0;:::o;56903:181::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;56985:8:::1;56972:10;;:21;;;;;;;;;;;;;;;;;;57004:36;57031:8;57004:22;:26;;:36;;;;:::i;:::-;;57051:25;57067:8;57051:11;:15;;:25;;;;:::i;:::-;;56903:181:::0;:::o;34176:151::-;34265:7;34292:11;:18;34304:5;34292:18;;;;;;;;;;;;;;;:27;34311:7;34292:27;;;;;;;;;;;;;;;;34285:34;;34176:151;;;;:::o;56677:105::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;56767:7:::1;56748:16;:26;;;;56677:105:::0;:::o;26360:192::-;25691:12;:10;:12::i;:::-;25680:23;;:7;:5;:7::i;:::-;:23;;;25672:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;26469:1:::1;26449:22;;:8;:22;;;;26441:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;26525:19;26535:8;26525:9;:19::i;:::-;26360:192:::0;:::o;14761:152::-;14831:4;14855:50;14860:3;:10;;14896:5;14880:23;;14872:32;;14855:4;:50::i;:::-;14848:57;;14761:152;;;;:::o;41408:125::-;;;;:::o;20283:114::-;20348:7;20375;:14;;;20368:21;;20283:114;;;:::o;24248:98::-;24301:7;24328:10;24321:17;;24248:98;:::o;15089:158::-;15162:4;15186:53;15194:3;:10;;15230:5;15214:23;;15206:32;;15186:7;:53::i;:::-;15179:60;;15089:158;;;;:::o;40428:380::-;40581:1;40564:19;;:5;:19;;;;40556:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;40662:1;40643:21;;:7;:21;;;;40635:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;40746:6;40716:11;:18;40728:5;40716:18;;;;;;;;;;;;;;;:27;40735:7;40716:27;;;;;;;;;;;;;;;:36;;;;40784:7;40768:32;;40777:5;40768:32;;;40793:6;40768:32;;;;;;:::i;:::-;;;;;;;;40428:380;;;:::o;37647:733::-;37805:1;37787:20;;:6;:20;;;;37779:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;37889:1;37868:23;;:9;:23;;;;37860:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;37944:47;37965:6;37973:9;37984:6;37944:20;:47::i;:::-;38004:21;38028:9;:17;38038:6;38028:17;;;;;;;;;;;;;;;;38004:41;;38081:6;38064:13;:23;;38056:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;38202:6;38186:13;:22;38166:9;:17;38176:6;38166:17;;;;;;;;;;;;;;;:42;;;;38254:6;38230:9;:20;38240:9;38230:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;38295:9;38278:35;;38287:6;38278:35;;;38306:6;38278:35;;;;;;:::i;:::-;;;;;;;;38326:46;38346:6;38354:9;38365:6;38326:19;:46::i;:::-;37768:612;37647:733;;;:::o;48680:1619::-;48769:4;48775:7;48816:1;48803:10;:14;48795:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;48877:23;:21;:23::i;:::-;48863:10;:37;;48855:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;50073:13;50089:40;50118:10;50089:9;:13;;:28;;:40;;;;:::i;:::-;50073:56;;50155:9;:13;;:20;;;;50146:5;:29;50142:150;;;50200:5;50207:1;50192:17;;;;;;;50142:150;50250:4;50256:9;:16;;50273:5;50256:23;;;;;;;;:::i;:::-;;;;;;;;;;50242:38;;;;;48680:1619;;;;;;:::o;46701:223::-;46748:7;46768:30;:18;:28;:30::i;:::-;46811:17;46831:23;:21;:23::i;:::-;46811:43;;46870:19;46879:9;46870:19;;;;;;:::i;:::-;;;;;;;;46907:9;46900:16;;;46701:223;:::o;56049:315::-;56101:4;56118:20;56141:1;56118:24;;56168:6;56163:130;56184:31;:22;:29;:31::i;:::-;56180:1;:35;56163:130;;;56254:39;56264:28;56290:1;56264:22;:25;;:28;;;;:::i;:::-;56254:9;:39::i;:::-;56235:58;;;;;:::i;:::-;;;56217:3;;;;;:::i;:::-;;;;56163:130;;;;56341:15;56325:13;:11;:13::i;:::-;:31;;;;:::i;:::-;56318:38;;;56049:315;:::o;26560:173::-;26616:16;26635:6;;;;;;;;;;;26616:25;;26661:8;26652:6;;:17;;;;;;;;;;;;;;;;;;26716:8;26685:40;;26706:8;26685:40;;;;;;;;;;;;26605:128;26560:173;:::o;15333:167::-;15413:4;15437:55;15447:3;:10;;15483:5;15467:23;;15459:32;;15437:9;:55::i;:::-;15430:62;;15333:167;;;;:::o;3530:98::-;3588:7;3619:1;3615;:5;;;;:::i;:::-;3608:12;;3530:98;;;;:::o;3929:::-;3987:7;4018:1;4014;:5;;;;:::i;:::-;4007:12;;3929:98;;;;:::o;3173:::-;3231:7;3262:1;3258;:5;;;;:::i;:::-;3251:12;;3173:98;;;;:::o;54394:1392::-;54439:19;54461:24;54479:4;54461:9;:24::i;:::-;54439:46;;54540:7;54521:16;;:26;;;;:::i;:::-;54502:14;:46;;:77;;;;;54577:1;54552:27;;:13;;;;;;;;;;;:27;;;;54502:77;54498:1281;;;54596:19;54618:21;54637:1;54618:14;:18;;:21;;;;:::i;:::-;54596:43;;54654:24;54681:34;54700:14;54681;:18;;:34;;;;:::i;:::-;54654:61;;54730:17;54750:21;54730:41;;54835:22;54874:1;54860:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54835:41;;54910:4;54891:5;54897:1;54891:8;;;;;;;;:::i;:::-;;;;;;;:24;;;;;;;;;;;54949:8;;;;;;;;;;;54930:5;54936:1;54930:8;;;;;;;;:::i;:::-;;;;;;;:28;;;;;;;;;;;54973:72;54990:4;55005:17;;;;;;;;;;;55025:19;54973:8;:72::i;:::-;55060:17;;;;;;;;;;;:68;;;55147:19;55185:1;55205:5;55237:4;55261:15;55060:231;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55320:14;55337:39;55363:12;55337:21;:25;;:39;;;;:::i;:::-;55320:56;;55454:67;55471:4;55486:17;;;;;;;;;;;55506:14;55454:8;:67::i;:::-;55536:17;;;;;;;;;;;:33;;;55577:9;55614:4;55638:14;55671:1;55691;55711:7;:5;:7::i;:::-;55737:15;55536:231;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;54581:1198;;;;;54498:1281;54428:1358;54394:1392::o;8676:414::-;8739:4;8761:21;8771:3;8776:5;8761:9;:21::i;:::-;8756:327;;8799:3;:11;;8816:5;8799:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8982:3;:11;;:18;;;;8960:3;:12;;:19;8973:5;8960:19;;;;;;;;;;;:40;;;;9022:4;9015:11;;;;8756:327;9066:5;9059:12;;8676:414;;;;;:::o;9266:1420::-;9332:4;9450:18;9471:3;:12;;:19;9484:5;9471:19;;;;;;;;;;;;9450:40;;9521:1;9507:10;:15;9503:1176;;9882:21;9919:1;9906:10;:14;;;;:::i;:::-;9882:38;;9935:17;9976:1;9955:3;:11;;:18;;;;:22;;;;:::i;:::-;9935:42;;10011:13;9998:9;:26;9994:405;;10045:17;10065:3;:11;;10077:9;10065:22;;;;;;;;:::i;:::-;;;;;;;;;;10045:42;;10219:9;10190:3;:11;;10202:13;10190:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;10330:10;10304:3;:12;;:23;10317:9;10304:23;;;;;;;;;;;:36;;;;10026:373;9994:405;10480:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;10575:3;:12;;:19;10588:5;10575:19;;;;;;;;;;;10568:26;;;10618:4;10611:11;;;;;;;9503:1176;10662:5;10655:12;;;9266:1420;;;;;:::o;48050:622::-;48193:44;48220:4;48226:2;48230:6;48193:26;:44::i;:::-;48270:1;48254:18;;:4;:18;;;48250:415;;;48310:26;48333:2;48310:22;:26::i;:::-;48351:28;:26;:28::i;:::-;48250:415;;;48415:1;48401:16;;:2;:16;;;48397:268;;;48455:28;48478:4;48455:22;:28::i;:::-;48498;:26;:28::i;:::-;48397:268;;;48584:28;48607:4;48584:22;:28::i;:::-;48627:26;48650:2;48627:22;:26::i;:::-;48397:268;48250:415;48050:622;;;:::o;42137:124::-;;;;:::o;46990:127::-;47054:7;47081:28;:18;:26;:28::i;:::-;47074:35;;46990:127;:::o;22698:918::-;22787:7;22827:1;22811:5;:12;;;;:17;22807:58;;;22852:1;22845:8;;;;22807:58;22877:11;22903:12;22918:5;:12;;;;22903:27;;22943:424;22956:4;22950:3;:10;22943:424;;;22977:11;22991:23;23004:3;23009:4;22991:12;:23::i;:::-;22977:37;;23248:7;23235:5;23241:3;23235:10;;;;;;;;:::i;:::-;;;;;;;;;;:20;23231:125;;;23283:3;23276:10;;23231:125;;;23339:1;23333:3;:7;;;;:::i;:::-;23327:13;;23231:125;22962:405;22943:424;;;23493:1;23487:3;:7;:36;;;;;23516:7;23498:5;23510:1;23504:3;:7;;;;:::i;:::-;23498:14;;;;;;;;:::i;:::-;;;;;;;;;;:25;23487:36;23483:126;;;23553:1;23547:3;:7;;;;:::i;:::-;23540:14;;;;;;23483:126;23594:3;23587:10;;;;22698:918;;;;;:::o;20405:127::-;20512:1;20494:7;:14;;;:19;;;;;;;;;;;20405:127;:::o;15586:117::-;15649:7;15676:19;15684:3;:10;;15676:7;:19::i;:::-;15669:26;;15586:117;;;:::o;16057:158::-;16131:7;16182:22;16186:3;:10;;16198:5;16182:3;:22::i;:::-;16174:31;;16151:56;;16057:158;;;;:::o;10772:129::-;10845:4;10892:1;10869:3;:12;;:19;10882:5;10869:19;;;;;;;;;;;;:24;;10862:31;;10772:129;;;;:::o;50307:146::-;50375:70;50391:24;:33;50416:7;50391:33;;;;;;;;;;;;;;;50426:18;50436:7;50426:9;:18::i;:::-;50375:15;:70::i;:::-;50307:146;:::o;50461:118::-;50518:53;50534:21;50557:13;:11;:13::i;:::-;50518:15;:53::i;:::-;50461:118::o;21535:156::-;21597:7;21682:1;21677;21673;:5;21672:11;;;;:::i;:::-;21667:1;21663;:5;21662:21;;;;:::i;:::-;21655:28;;21535:156;;;;:::o;10987:109::-;11043:7;11070:3;:11;;:18;;;;11063:25;;10987:109;;;:::o;11450:120::-;11517:7;11544:3;:11;;11556:5;11544:18;;;;;;;;:::i;:::-;;;;;;;;;;11537:25;;11450:120;;;;:::o;50587:310::-;50682:17;50702:23;:21;:23::i;:::-;50682:43;;50773:9;50740:30;50756:9;:13;;50740:15;:30::i;:::-;:42;50736:154;;;50799:9;:13;;50818:9;50799:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50843:9;:16;;50865:12;50843:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50736:154;50671:226;50587:310;;:::o;50905:212::-;50975:7;51013:1;50999:3;:10;;;;:15;50995:115;;;51038:1;51031:8;;;;50995:115;51079:3;51096:1;51083:3;:10;;;;:14;;;;:::i;:::-;51079:19;;;;;;;;:::i;:::-;;;;;;;;;;51072:26;;50905:212;;;;:::o;7:139:1:-;53:5;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;7:139;;;;:::o;152:::-;198:5;236:6;223:20;214:29;;252:33;279:5;252:33;:::i;:::-;152:139;;;;:::o;297:143::-;354:5;385:6;379:13;370:22;;401:33;428:5;401:33;:::i;:::-;297:143;;;;:::o;446:329::-;505:6;554:2;542:9;533:7;529:23;525:32;522:119;;;560:79;;:::i;:::-;522:119;680:1;705:53;750:7;741:6;730:9;726:22;705:53;:::i;:::-;695:63;;651:117;446:329;;;;:::o;781:474::-;849:6;857;906:2;894:9;885:7;881:23;877:32;874:119;;;912:79;;:::i;:::-;874:119;1032:1;1057:53;1102:7;1093:6;1082:9;1078:22;1057:53;:::i;:::-;1047:63;;1003:117;1159:2;1185:53;1230:7;1221:6;1210:9;1206:22;1185:53;:::i;:::-;1175:63;;1130:118;781:474;;;;;:::o;1261:619::-;1338:6;1346;1354;1403:2;1391:9;1382:7;1378:23;1374:32;1371:119;;;1409:79;;:::i;:::-;1371:119;1529:1;1554:53;1599:7;1590:6;1579:9;1575:22;1554:53;:::i;:::-;1544:63;;1500:117;1656:2;1682:53;1727:7;1718:6;1707:9;1703:22;1682:53;:::i;:::-;1672:63;;1627:118;1784:2;1810:53;1855:7;1846:6;1835:9;1831:22;1810:53;:::i;:::-;1800:63;;1755:118;1261:619;;;;;:::o;1886:474::-;1954:6;1962;2011:2;1999:9;1990:7;1986:23;1982:32;1979:119;;;2017:79;;:::i;:::-;1979:119;2137:1;2162:53;2207:7;2198:6;2187:9;2183:22;2162:53;:::i;:::-;2152:63;;2108:117;2264:2;2290:53;2335:7;2326:6;2315:9;2311:22;2290:53;:::i;:::-;2280:63;;2235:118;1886:474;;;;;:::o;2366:329::-;2425:6;2474:2;2462:9;2453:7;2449:23;2445:32;2442:119;;;2480:79;;:::i;:::-;2442:119;2600:1;2625:53;2670:7;2661:6;2650:9;2646:22;2625:53;:::i;:::-;2615:63;;2571:117;2366:329;;;;:::o;2701:663::-;2789:6;2797;2805;2854:2;2842:9;2833:7;2829:23;2825:32;2822:119;;;2860:79;;:::i;:::-;2822:119;2980:1;3005:64;3061:7;3052:6;3041:9;3037:22;3005:64;:::i;:::-;2995:74;;2951:128;3118:2;3144:64;3200:7;3191:6;3180:9;3176:22;3144:64;:::i;:::-;3134:74;;3089:129;3257:2;3283:64;3339:7;3330:6;3319:9;3315:22;3283:64;:::i;:::-;3273:74;;3228:129;2701:663;;;;;:::o;3370:179::-;3439:10;3460:46;3502:3;3494:6;3460:46;:::i;:::-;3538:4;3533:3;3529:14;3515:28;;3370:179;;;;:::o;3555:108::-;3632:24;3650:5;3632:24;:::i;:::-;3627:3;3620:37;3555:108;;:::o;3669:118::-;3756:24;3774:5;3756:24;:::i;:::-;3751:3;3744:37;3669:118;;:::o;3823:732::-;3942:3;3971:54;4019:5;3971:54;:::i;:::-;4041:86;4120:6;4115:3;4041:86;:::i;:::-;4034:93;;4151:56;4201:5;4151:56;:::i;:::-;4230:7;4261:1;4246:284;4271:6;4268:1;4265:13;4246:284;;;4347:6;4341:13;4374:63;4433:3;4418:13;4374:63;:::i;:::-;4367:70;;4460:60;4513:6;4460:60;:::i;:::-;4450:70;;4306:224;4293:1;4290;4286:9;4281:14;;4246:284;;;4250:14;4546:3;4539:10;;3947:608;;;3823:732;;;;:::o;4561:109::-;4642:21;4657:5;4642:21;:::i;:::-;4637:3;4630:34;4561:109;;:::o;4676:147::-;4771:45;4810:5;4771:45;:::i;:::-;4766:3;4759:58;4676:147;;:::o;4829:364::-;4917:3;4945:39;4978:5;4945:39;:::i;:::-;5000:71;5064:6;5059:3;5000:71;:::i;:::-;4993:78;;5080:52;5125:6;5120:3;5113:4;5106:5;5102:16;5080:52;:::i;:::-;5157:29;5179:6;5157:29;:::i;:::-;5152:3;5148:39;5141:46;;4921:272;4829:364;;;;:::o;5199:366::-;5341:3;5362:67;5426:2;5421:3;5362:67;:::i;:::-;5355:74;;5438:93;5527:3;5438:93;:::i;:::-;5556:2;5551:3;5547:12;5540:19;;5199:366;;;:::o;5571:::-;5713:3;5734:67;5798:2;5793:3;5734:67;:::i;:::-;5727:74;;5810:93;5899:3;5810:93;:::i;:::-;5928:2;5923:3;5919:12;5912:19;;5571:366;;;:::o;5943:::-;6085:3;6106:67;6170:2;6165:3;6106:67;:::i;:::-;6099:74;;6182:93;6271:3;6182:93;:::i;:::-;6300:2;6295:3;6291:12;6284:19;;5943:366;;;:::o;6315:::-;6457:3;6478:67;6542:2;6537:3;6478:67;:::i;:::-;6471:74;;6554:93;6643:3;6554:93;:::i;:::-;6672:2;6667:3;6663:12;6656:19;;6315:366;;;:::o;6687:::-;6829:3;6850:67;6914:2;6909:3;6850:67;:::i;:::-;6843:74;;6926:93;7015:3;6926:93;:::i;:::-;7044:2;7039:3;7035:12;7028:19;;6687:366;;;:::o;7059:::-;7201:3;7222:67;7286:2;7281:3;7222:67;:::i;:::-;7215:74;;7298:93;7387:3;7298:93;:::i;:::-;7416:2;7411:3;7407:12;7400:19;;7059:366;;;:::o;7431:::-;7573:3;7594:67;7658:2;7653:3;7594:67;:::i;:::-;7587:74;;7670:93;7759:3;7670:93;:::i;:::-;7788:2;7783:3;7779:12;7772:19;;7431:366;;;:::o;7803:::-;7945:3;7966:67;8030:2;8025:3;7966:67;:::i;:::-;7959:74;;8042:93;8131:3;8042:93;:::i;:::-;8160:2;8155:3;8151:12;8144:19;;7803:366;;;:::o;8175:::-;8317:3;8338:67;8402:2;8397:3;8338:67;:::i;:::-;8331:74;;8414:93;8503:3;8414:93;:::i;:::-;8532:2;8527:3;8523:12;8516:19;;8175:366;;;:::o;8547:::-;8689:3;8710:67;8774:2;8769:3;8710:67;:::i;:::-;8703:74;;8786:93;8875:3;8786:93;:::i;:::-;8904:2;8899:3;8895:12;8888:19;;8547:366;;;:::o;8919:::-;9061:3;9082:67;9146:2;9141:3;9082:67;:::i;:::-;9075:74;;9158:93;9247:3;9158:93;:::i;:::-;9276:2;9271:3;9267:12;9260:19;;8919:366;;;:::o;9291:::-;9433:3;9454:67;9518:2;9513:3;9454:67;:::i;:::-;9447:74;;9530:93;9619:3;9530:93;:::i;:::-;9648:2;9643:3;9639:12;9632:19;;9291:366;;;:::o;9663:118::-;9750:24;9768:5;9750:24;:::i;:::-;9745:3;9738:37;9663:118;;:::o;9787:112::-;9870:22;9886:5;9870:22;:::i;:::-;9865:3;9858:35;9787:112;;:::o;9905:222::-;9998:4;10036:2;10025:9;10021:18;10013:26;;10049:71;10117:1;10106:9;10102:17;10093:6;10049:71;:::i;:::-;9905:222;;;;:::o;10133:807::-;10382:4;10420:3;10409:9;10405:19;10397:27;;10434:71;10502:1;10491:9;10487:17;10478:6;10434:71;:::i;:::-;10515:72;10583:2;10572:9;10568:18;10559:6;10515:72;:::i;:::-;10597:80;10673:2;10662:9;10658:18;10649:6;10597:80;:::i;:::-;10687;10763:2;10752:9;10748:18;10739:6;10687:80;:::i;:::-;10777:73;10845:3;10834:9;10830:19;10821:6;10777:73;:::i;:::-;10860;10928:3;10917:9;10913:19;10904:6;10860:73;:::i;:::-;10133:807;;;;;;;;;:::o;10946:210::-;11033:4;11071:2;11060:9;11056:18;11048:26;;11084:65;11146:1;11135:9;11131:17;11122:6;11084:65;:::i;:::-;10946:210;;;;:::o;11162:313::-;11275:4;11313:2;11302:9;11298:18;11290:26;;11362:9;11356:4;11352:20;11348:1;11337:9;11333:17;11326:47;11390:78;11463:4;11454:6;11390:78;:::i;:::-;11382:86;;11162:313;;;;:::o;11481:419::-;11647:4;11685:2;11674:9;11670:18;11662:26;;11734:9;11728:4;11724:20;11720:1;11709:9;11705:17;11698:47;11762:131;11888:4;11762:131;:::i;:::-;11754:139;;11481:419;;;:::o;11906:::-;12072:4;12110:2;12099:9;12095:18;12087:26;;12159:9;12153:4;12149:20;12145:1;12134:9;12130:17;12123:47;12187:131;12313:4;12187:131;:::i;:::-;12179:139;;11906:419;;;:::o;12331:::-;12497:4;12535:2;12524:9;12520:18;12512:26;;12584:9;12578:4;12574:20;12570:1;12559:9;12555:17;12548:47;12612:131;12738:4;12612:131;:::i;:::-;12604:139;;12331:419;;;:::o;12756:::-;12922:4;12960:2;12949:9;12945:18;12937:26;;13009:9;13003:4;12999:20;12995:1;12984:9;12980:17;12973:47;13037:131;13163:4;13037:131;:::i;:::-;13029:139;;12756:419;;;:::o;13181:::-;13347:4;13385:2;13374:9;13370:18;13362:26;;13434:9;13428:4;13424:20;13420:1;13409:9;13405:17;13398:47;13462:131;13588:4;13462:131;:::i;:::-;13454:139;;13181:419;;;:::o;13606:::-;13772:4;13810:2;13799:9;13795:18;13787:26;;13859:9;13853:4;13849:20;13845:1;13834:9;13830:17;13823:47;13887:131;14013:4;13887:131;:::i;:::-;13879:139;;13606:419;;;:::o;14031:::-;14197:4;14235:2;14224:9;14220:18;14212:26;;14284:9;14278:4;14274:20;14270:1;14259:9;14255:17;14248:47;14312:131;14438:4;14312:131;:::i;:::-;14304:139;;14031:419;;;:::o;14456:::-;14622:4;14660:2;14649:9;14645:18;14637:26;;14709:9;14703:4;14699:20;14695:1;14684:9;14680:17;14673:47;14737:131;14863:4;14737:131;:::i;:::-;14729:139;;14456:419;;;:::o;14881:::-;15047:4;15085:2;15074:9;15070:18;15062:26;;15134:9;15128:4;15124:20;15120:1;15109:9;15105:17;15098:47;15162:131;15288:4;15162:131;:::i;:::-;15154:139;;14881:419;;;:::o;15306:::-;15472:4;15510:2;15499:9;15495:18;15487:26;;15559:9;15553:4;15549:20;15545:1;15534:9;15530:17;15523:47;15587:131;15713:4;15587:131;:::i;:::-;15579:139;;15306:419;;;:::o;15731:::-;15897:4;15935:2;15924:9;15920:18;15912:26;;15984:9;15978:4;15974:20;15970:1;15959:9;15955:17;15948:47;16012:131;16138:4;16012:131;:::i;:::-;16004:139;;15731:419;;;:::o;16156:::-;16322:4;16360:2;16349:9;16345:18;16337:26;;16409:9;16403:4;16399:20;16395:1;16384:9;16380:17;16373:47;16437:131;16563:4;16437:131;:::i;:::-;16429:139;;16156:419;;;:::o;16581:222::-;16674:4;16712:2;16701:9;16697:18;16689:26;;16725:71;16793:1;16782:9;16778:17;16769:6;16725:71;:::i;:::-;16581:222;;;;:::o;16809:831::-;17072:4;17110:3;17099:9;17095:19;17087:27;;17124:71;17192:1;17181:9;17177:17;17168:6;17124:71;:::i;:::-;17205:80;17281:2;17270:9;17266:18;17257:6;17205:80;:::i;:::-;17332:9;17326:4;17322:20;17317:2;17306:9;17302:18;17295:48;17360:108;17463:4;17454:6;17360:108;:::i;:::-;17352:116;;17478:72;17546:2;17535:9;17531:18;17522:6;17478:72;:::i;:::-;17560:73;17628:3;17617:9;17613:19;17604:6;17560:73;:::i;:::-;16809:831;;;;;;;;:::o;17646:332::-;17767:4;17805:2;17794:9;17790:18;17782:26;;17818:71;17886:1;17875:9;17871:17;17862:6;17818:71;:::i;:::-;17899:72;17967:2;17956:9;17952:18;17943:6;17899:72;:::i;:::-;17646:332;;;;;:::o;17984:214::-;18073:4;18111:2;18100:9;18096:18;18088:26;;18124:67;18188:1;18177:9;18173:17;18164:6;18124:67;:::i;:::-;17984:214;;;;:::o;18285:132::-;18352:4;18375:3;18367:11;;18405:4;18400:3;18396:14;18388:22;;18285:132;;;:::o;18423:114::-;18490:6;18524:5;18518:12;18508:22;;18423:114;;;:::o;18543:99::-;18595:6;18629:5;18623:12;18613:22;;18543:99;;;:::o;18648:113::-;18718:4;18750;18745:3;18741:14;18733:22;;18648:113;;;:::o;18767:184::-;18866:11;18900:6;18895:3;18888:19;18940:4;18935:3;18931:14;18916:29;;18767:184;;;;:::o;18957:169::-;19041:11;19075:6;19070:3;19063:19;19115:4;19110:3;19106:14;19091:29;;18957:169;;;;:::o;19132:305::-;19172:3;19191:20;19209:1;19191:20;:::i;:::-;19186:25;;19225:20;19243:1;19225:20;:::i;:::-;19220:25;;19379:1;19311:66;19307:74;19304:1;19301:81;19298:107;;;19385:18;;:::i;:::-;19298:107;19429:1;19426;19422:9;19415:16;;19132:305;;;;:::o;19443:185::-;19483:1;19500:20;19518:1;19500:20;:::i;:::-;19495:25;;19534:20;19552:1;19534:20;:::i;:::-;19529:25;;19573:1;19563:35;;19578:18;;:::i;:::-;19563:35;19620:1;19617;19613:9;19608:14;;19443:185;;;;:::o;19634:348::-;19674:7;19697:20;19715:1;19697:20;:::i;:::-;19692:25;;19731:20;19749:1;19731:20;:::i;:::-;19726:25;;19919:1;19851:66;19847:74;19844:1;19841:81;19836:1;19829:9;19822:17;19818:105;19815:131;;;19926:18;;:::i;:::-;19815:131;19974:1;19971;19967:9;19956:20;;19634:348;;;;:::o;19988:191::-;20028:4;20048:20;20066:1;20048:20;:::i;:::-;20043:25;;20082:20;20100:1;20082:20;:::i;:::-;20077:25;;20121:1;20118;20115:8;20112:34;;;20126:18;;:::i;:::-;20112:34;20171:1;20168;20164:9;20156:17;;19988:191;;;;:::o;20185:96::-;20222:7;20251:24;20269:5;20251:24;:::i;:::-;20240:35;;20185:96;;;:::o;20287:90::-;20321:7;20364:5;20357:13;20350:21;20339:32;;20287:90;;;:::o;20383:126::-;20420:7;20460:42;20453:5;20449:54;20438:65;;20383:126;;;:::o;20515:77::-;20552:7;20581:5;20570:16;;20515:77;;;:::o;20598:86::-;20633:7;20673:4;20666:5;20662:16;20651:27;;20598:86;;;:::o;20690:121::-;20748:9;20781:24;20799:5;20781:24;:::i;:::-;20768:37;;20690:121;;;:::o;20817:307::-;20885:1;20895:113;20909:6;20906:1;20903:13;20895:113;;;20994:1;20989:3;20985:11;20979:18;20975:1;20970:3;20966:11;20959:39;20931:2;20928:1;20924:10;20919:15;;20895:113;;;21026:6;21023:1;21020:13;21017:101;;;21106:1;21097:6;21092:3;21088:16;21081:27;21017:101;20866:258;20817:307;;;:::o;21130:320::-;21174:6;21211:1;21205:4;21201:12;21191:22;;21258:1;21252:4;21248:12;21279:18;21269:81;;21335:4;21327:6;21323:17;21313:27;;21269:81;21397:2;21389:6;21386:14;21366:18;21363:38;21360:84;;;21416:18;;:::i;:::-;21360:84;21181:269;21130:320;;;:::o;21456:233::-;21495:3;21518:24;21536:5;21518:24;:::i;:::-;21509:33;;21564:66;21557:5;21554:77;21551:103;;;21634:18;;:::i;:::-;21551:103;21681:1;21674:5;21670:13;21663:20;;21456:233;;;:::o;21695:180::-;21743:77;21740:1;21733:88;21840:4;21837:1;21830:15;21864:4;21861:1;21854:15;21881:180;21929:77;21926:1;21919:88;22026:4;22023:1;22016:15;22050:4;22047:1;22040:15;22067:180;22115:77;22112:1;22105:88;22212:4;22209:1;22202:15;22236:4;22233:1;22226:15;22253:180;22301:77;22298:1;22291:88;22398:4;22395:1;22388:15;22422:4;22419:1;22412:15;22439:180;22487:77;22484:1;22477:88;22584:4;22581:1;22574:15;22608:4;22605:1;22598:15;22625:180;22673:77;22670:1;22663:88;22770:4;22767:1;22760:15;22794:4;22791:1;22784:15;22934:117;23043:1;23040;23033:12;23057:102;23098:6;23149:2;23145:7;23140:2;23133:5;23129:14;23125:28;23115:38;;23057:102;;;:::o;23165:179::-;23305:31;23301:1;23293:6;23289:14;23282:55;23165:179;:::o;23350:222::-;23490:34;23486:1;23478:6;23474:14;23467:58;23559:5;23554:2;23546:6;23542:15;23535:30;23350:222;:::o;23578:225::-;23718:34;23714:1;23706:6;23702:14;23695:58;23787:8;23782:2;23774:6;23770:15;23763:33;23578:225;:::o;23809:221::-;23949:34;23945:1;23937:6;23933:14;23926:58;24018:4;24013:2;24005:6;24001:15;23994:29;23809:221;:::o;24036:160::-;24176:12;24172:1;24164:6;24160:14;24153:36;24036:160;:::o;24202:225::-;24342:34;24338:1;24330:6;24326:14;24319:58;24411:8;24406:2;24398:6;24394:15;24387:33;24202:225;:::o;24433:227::-;24573:34;24569:1;24561:6;24557:14;24550:58;24642:10;24637:2;24629:6;24625:15;24618:35;24433:227;:::o;24666:182::-;24806:34;24802:1;24794:6;24790:14;24783:58;24666:182;:::o;24854:224::-;24994:34;24990:1;24982:6;24978:14;24971:58;25063:7;25058:2;25050:6;25046:15;25039:32;24854:224;:::o;25084:223::-;25224:34;25220:1;25212:6;25208:14;25201:58;25293:6;25288:2;25280:6;25276:15;25269:31;25084:223;:::o;25313:172::-;25453:24;25449:1;25441:6;25437:14;25430:48;25313:172;:::o;25491:224::-;25631:34;25627:1;25619:6;25615:14;25608:58;25700:7;25695:2;25687:6;25683:15;25676:32;25491:224;:::o;25721:122::-;25794:24;25812:5;25794:24;:::i;:::-;25787:5;25784:35;25774:63;;25833:1;25830;25823:12;25774:63;25721:122;:::o;25849:::-;25922:24;25940:5;25922:24;:::i;:::-;25915:5;25912:35;25902:63;;25961:1;25958;25951:12;25902:63;25849:122;:::o

ipfs://055e791d0fec1e2f4b4a574b5cb4eb3e81e09d03373996d4f8d26c554eb4f27c