Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Ownable
•    - function transferOwnership(
•    - function renounceOwnership()
•  contract AddressSet
•    - function addAddressToSet(
•    - function removeAddressFromSet(
•    - function removeSet(bytes32 key)
•    - function isAddressInSet(
•    - function numAddressesInSet(bytes32 ke ...
•    - function addressesInSet(bytes32 key)
• library strings
•    - function memcpy(uint dest, uint src, ...
•    - function toSlice(string memory self)
•    - function len(bytes32 self)
•    - function toSliceB32(bytes32 self)
•    - function copy(slice memory self)
•    - function toString(slice memory self)
•    - function len(slice memory self)
•    - function empty(slice memory self)
•    - function compare(slice memory self, s ...
•    - function equals(slice memory self, sl ...
•    - function nextRune(slice memory self, ...
•    - function nextRune(slice memory self)
•    - function ord(slice memory self)
•    - function keccak(slice memory self)
•    - function startsWith(slice memory self ...
•    - function beyond(slice memory self, sl ...
•    - function endsWith(slice memory self, ...
•    - function until(slice memory self, sli ...
•    - function findPtr(uint selflen, uint s ...
•    - function rfindPtr(uint selflen, uint ...
•    - function find(slice memory self, slic ...
•    - function rfind(slice memory self, sli ...
•    - function split(slice memory self, sli ...
•    - function split(slice memory self, sli ...
•    - function rsplit(slice memory self, sl ...
•    - function rsplit(slice memory self, sl ...
•    - function count(slice memory self, sli ...
•    - function contains(slice memory self, ...
•    - function concat(slice memory self, sl ...
•    - function join(slice memory self, slic ...
• interface ENSRegistry
•    - function setSubnodeOwner(bytes32 node ...
•    - function setResolver(bytes32 node, ad ...
•    - function setOwner(bytes32 node, addre ...
•    - function setTTL(bytes32 node, uint64 ...
•    - function owner(bytes32 node)
•    - function resolver(bytes32 node)
•    - function ttl(bytes32 node)
•    - function addr(bytes32 _node)
•    - function setAddr(bytes32 _node, addre ...
•    - function name(bytes32 _node)
•    - function setName(bytes32 _node, strin ...
•    - function claim(address _owner)
•    - function claimWithResolver(address _o ...
•    - function setName(string memory _name)
•    - function node(address _addr)
• library MathUint
•    - function mul(
•    - function sub(
•    - function add(
• library BytesUtil
•    - function slice(
•    - function toAddress(bytes memory _byte ...
•    - function toUint8(bytes memory _bytes, ...
•    - function toUint16(bytes memory _bytes ...
•    - function toUint24(bytes memory _bytes ...
•    - function toUint32(bytes memory _bytes ...
•    - function toUint64(bytes memory _bytes ...
•    - function toUint96(bytes memory _bytes ...
•    - function toUint128(bytes memory _byte ...
•    - function toUint(bytes memory _bytes, ...
•    - function toBytes4(bytes memory _bytes ...
•    - function toBytes32(bytes memory _byte ...
•    - function fastSHA256(
• library AddressUtil
•    - function isContract(
•    - function toPayable(
•    - function sendETH(
•    - function sendETHAndVerify(
• library SignatureUtil
•    - function verifySignatures(
•    - function verifySignatures(
•    - function verifySignature(
•    - function verifySignature(
•    - function recoverECDSASigner(
•    - function recoverECDSASigner(
•    - function verifyEOASignature(
•    - function verifyERC1271Signature(
•    - function verifyERC1271WithBytes(
•    - function verifyERC1271WithBytes32(
•  contract ENSConsumer
•    - function resolveEns(bytes32 _node)
•    - function getENSRegistry()
•    - function getENSReverseRegistrar()
•  contract Claimable is Ownable
•    - function transferOwnership(
•    - function claimOwnership()
•  contract OwnerManagable is Claimab ...
•    - function managers()
•    - function numManagers()
•    - function isManager(address addr)
•    - function addManager(address manager)
•    - function removeManager(address manage ...
•    - function addManagerInternal(address m ...
• interface IENSManager
•    - function changeRootnodeOwner(address ...
•    - function isAvailable(bytes32 _subnode ...
•    - function resolveName(address _wallet)
•    - function register(
•  contract BaseENSManager is IENSMan ... *
•    - function changeRootnodeOwner(address ...
•    - function changeENSResolver(address _e ...
•    - function register(
•    - function resolveName(address _wallet)
•    - function isAvailable(bytes32 _subnode ...
•    - function verifyApproval(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-08-25
*/

// SPDX-License-Identifier: Apache-2.0
// Copyright 2017 Loopring Technology Limited.
pragma solidity ^0.7.0;


/// @title Ownable
/// @author Brecht Devos - <[email protected]>
/// @dev The Ownable contract has an owner address, and provides basic
///      authorization control functions, this simplifies the implementation of
///      "user permissions".
contract Ownable
{
    address public owner;

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

    /// @dev The Ownable constructor sets the original `owner` of the contract
    ///      to the sender.
    constructor()
    {
        owner = msg.sender;
    }

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

    /// @dev Allows the current owner to transfer control of the contract to a
    ///      new owner.
    /// @param newOwner The address to transfer ownership to.
    function transferOwnership(
        address newOwner
        )
        public
        virtual
        onlyOwner
    {
        require(newOwner != address(0), "ZERO_ADDRESS");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    function renounceOwnership()
        public
        onlyOwner
    {
        emit OwnershipTransferred(owner, address(0));
        owner = address(0);
    }
}

// Copyright 2017 Loopring Technology Limited.



/// @title AddressSet
/// @author Daniel Wang - <[email protected]>
contract AddressSet
{
    struct Set
    {
        address[] addresses;
        mapping (address => uint) positions;
        uint count;
    }
    mapping (bytes32 => Set) private sets;

    function addAddressToSet(
        bytes32 key,
        address addr,
        bool    maintainList
        ) internal
    {
        Set storage set = sets[key];
        require(set.positions[addr] == 0, "ALREADY_IN_SET");

        if (maintainList) {
            require(set.addresses.length == set.count, "PREVIOUSLY_NOT_MAINTAILED");
            set.addresses.push(addr);
        } else {
            require(set.addresses.length == 0, "MUST_MAINTAIN");
        }

        set.count += 1;
        set.positions[addr] = set.count;
    }

    function removeAddressFromSet(
        bytes32 key,
        address addr
        )
        internal
    {
        Set storage set = sets[key];
        uint pos = set.positions[addr];
        require(pos != 0, "NOT_IN_SET");

        delete set.positions[addr];
        set.count -= 1;

        if (set.addresses.length > 0) {
            address lastAddr = set.addresses[set.count];
            if (lastAddr != addr) {
                set.addresses[pos - 1] = lastAddr;
                set.positions[lastAddr] = pos;
            }
            set.addresses.pop();
        }
    }

    function removeSet(bytes32 key)
        internal
    {
        delete sets[key];
    }

    function isAddressInSet(
        bytes32 key,
        address addr
        )
        internal
        view
        returns (bool)
    {
        return sets[key].positions[addr] != 0;
    }

    function numAddressesInSet(bytes32 key)
        internal
        view
        returns (uint)
    {
        Set storage set = sets[key];
        return set.count;
    }

    function addressesInSet(bytes32 key)
        internal
        view
        returns (address[] memory)
    {
        Set storage set = sets[key];
        require(set.count == set.addresses.length, "NOT_MAINTAINED");
        return sets[key].addresses;
    }
}
/*
 * @title String & slice utility library for Solidity contracts.
 * @author Nick Johnson <[email protected]>
 *
 * @dev Functionality in this library is largely implemented using an
 *      abstraction called a 'slice'. A slice represents a part of a string -
 *      anything from the entire string to a single character, or even no
 *      characters at all (a 0-length slice). Since a slice only has to specify
 *      an offset and a length, copying and manipulating slices is a lot less
 *      expensive than copying and manipulating the strings they reference.
 *
 *      To further reduce gas costs, most functions on slice that need to return
 *      a slice modify the original one instead of allocating a new one; for
 *      instance, `s.split(".")` will return the text up to the first '.',
 *      modifying s to only contain the remainder of the string after the '.'.
 *      In situations where you do not want to modify the original slice, you
 *      can make a copy first with `.copy()`, for example:
 *      `s.copy().split(".")`. Try and avoid using this idiom in loops; since
 *      Solidity has no memory management, it will result in allocating many
 *      short-lived slices that are later discarded.
 *
 *      Functions that return two slices come in two versions: a non-allocating
 *      version that takes the second slice as an argument, modifying it in
 *      place, and an allocating version that allocates and returns the second
 *      slice; see `nextRune` for example.
 *
 *      Functions that have to copy string data will return strings rather than
 *      slices; these can be cast back to slices for further processing if
 *      required.
 *
 *      For convenience, some functions are provided with non-modifying
 *      variants that create a new slice and return both; for instance,
 *      `s.splitNew('.')` leaves s unmodified, and returns two values
 *      corresponding to the left and right parts of the string.
 */



/* solium-disable */
library strings {
    struct slice {
        uint _len;
        uint _ptr;
    }

    function memcpy(uint dest, uint src, uint len) private pure {
        // Copy word-length chunks while possible
        for(; len >= 32; len -= 32) {
            assembly {
                mstore(dest, mload(src))
            }
            dest += 32;
            src += 32;
        }

        // Copy remaining bytes
        uint mask = 256 ** (32 - len) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask))
            let destpart := and(mload(dest), mask)
            mstore(dest, or(destpart, srcpart))
        }
    }

    /*
     * @dev Returns a slice containing the entire string.
     * @param self The string to make a slice from.
     * @return A newly allocated slice containing the entire string.
     */
    function toSlice(string memory self) internal pure returns (slice memory) {
        uint ptr;
        assembly {
            ptr := add(self, 0x20)
        }
        return slice(bytes(self).length, ptr);
    }

    /*
     * @dev Returns the length of a null-terminated bytes32 string.
     * @param self The value to find the length of.
     * @return The length of the string, from 0 to 32.
     */
    function len(bytes32 self) internal pure returns (uint) {
        uint ret;
        if (self == 0)
            return 0;
        if (uint256(self) & 0xffffffffffffffffffffffffffffffff == 0) {
            ret += 16;
            self = bytes32(uint(self) / 0x100000000000000000000000000000000);
        }
        if (uint256(self) & 0xffffffffffffffff == 0) {
            ret += 8;
            self = bytes32(uint(self) / 0x10000000000000000);
        }
        if (uint256(self) & 0xffffffff == 0) {
            ret += 4;
            self = bytes32(uint(self) / 0x100000000);
        }
        if (uint256(self) & 0xffff == 0) {
            ret += 2;
            self = bytes32(uint(self) / 0x10000);
        }
        if (uint256(self) & 0xff == 0) {
            ret += 1;
        }
        return 32 - ret;
    }

    /*
     * @dev Returns a slice containing the entire bytes32, interpreted as a
     *      null-terminated utf-8 string.
     * @param self The bytes32 value to convert to a slice.
     * @return A new slice containing the value of the input argument up to the
     *         first null.
     */
    function toSliceB32(bytes32 self) internal pure returns (slice memory ret) {
        // Allocate space for `self` in memory, copy it there, and point ret at it
        assembly {
            let ptr := mload(0x40)
            mstore(0x40, add(ptr, 0x20))
            mstore(ptr, self)
            mstore(add(ret, 0x20), ptr)
        }
        ret._len = len(self);
    }

    /*
     * @dev Returns a new slice containing the same data as the current slice.
     * @param self The slice to copy.
     * @return A new slice containing the same data as `self`.
     */
    function copy(slice memory self) internal pure returns (slice memory) {
        return slice(self._len, self._ptr);
    }

    /*
     * @dev Copies a slice to a new string.
     * @param self The slice to copy.
     * @return A newly allocated string containing the slice's text.
     */
    function toString(slice memory self) internal pure returns (string memory) {
        string memory ret = new string(self._len);
        uint retptr;
        assembly { retptr := add(ret, 32) }

        memcpy(retptr, self._ptr, self._len);
        return ret;
    }

    /*
     * @dev Returns the length in runes of the slice. Note that this operation
     *      takes time proportional to the length of the slice; avoid using it
     *      in loops, and call `slice.empty()` if you only need to kblock.timestamp whether
     *      the slice is empty or not.
     * @param self The slice to operate on.
     * @return The length of the slice in runes.
     */
    function len(slice memory self) internal pure returns (uint l) {
        // Starting at ptr-31 means the LSB will be the byte we care about
        uint ptr = self._ptr - 31;
        uint end = ptr + self._len;
        for (l = 0; ptr < end; l++) {
            uint8 b;
            assembly { b := and(mload(ptr), 0xFF) }
            if (b < 0x80) {
                ptr += 1;
            } else if(b < 0xE0) {
                ptr += 2;
            } else if(b < 0xF0) {
                ptr += 3;
            } else if(b < 0xF8) {
                ptr += 4;
            } else if(b < 0xFC) {
                ptr += 5;
            } else {
                ptr += 6;
            }
        }
    }

    /*
     * @dev Returns true if the slice is empty (has a length of 0).
     * @param self The slice to operate on.
     * @return True if the slice is empty, False otherwise.
     */
    function empty(slice memory self) internal pure returns (bool) {
        return self._len == 0;
    }

    /*
     * @dev Returns a positive number if `other` comes lexicographically after
     *      `self`, a negative number if it comes before, or zero if the
     *      contents of the two slices are equal. Comparison is done per-rune,
     *      on unicode codepoints.
     * @param self The first slice to compare.
     * @param other The second slice to compare.
     * @return The result of the comparison.
     */
    function compare(slice memory self, slice memory other) internal pure returns (int) {
        uint shortest = self._len;
        if (other._len < self._len)
            shortest = other._len;

        uint selfptr = self._ptr;
        uint otherptr = other._ptr;
        for (uint idx = 0; idx < shortest; idx += 32) {
            uint a;
            uint b;
            assembly {
                a := mload(selfptr)
                b := mload(otherptr)
            }
            if (a != b) {
                // Mask out irrelevant bytes and check again
                uint256 mask = uint256(-1); // 0xffff...
                if(shortest < 32) {
                  mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
                }
                uint256 diff = (a & mask) - (b & mask);
                if (diff != 0)
                    return int(diff);
            }
            selfptr += 32;
            otherptr += 32;
        }
        return int(self._len) - int(other._len);
    }

    /*
     * @dev Returns true if the two slices contain the same text.
     * @param self The first slice to compare.
     * @param self The second slice to compare.
     * @return True if the slices are equal, false otherwise.
     */
    function equals(slice memory self, slice memory other) internal pure returns (bool) {
        return compare(self, other) == 0;
    }

    /*
     * @dev Extracts the first rune in the slice into `rune`, advancing the
     *      slice to point to the next rune and returning `self`.
     * @param self The slice to operate on.
     * @param rune The slice that will contain the first rune.
     * @return `rune`.
     */
    function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
        rune._ptr = self._ptr;

        if (self._len == 0) {
            rune._len = 0;
            return rune;
        }

        uint l;
        uint b;
        // Load the first byte of the rune into the LSBs of b
        assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
        if (b < 0x80) {
            l = 1;
        } else if(b < 0xE0) {
            l = 2;
        } else if(b < 0xF0) {
            l = 3;
        } else {
            l = 4;
        }

        // Check for truncated codepoints
        if (l > self._len) {
            rune._len = self._len;
            self._ptr += self._len;
            self._len = 0;
            return rune;
        }

        self._ptr += l;
        self._len -= l;
        rune._len = l;
        return rune;
    }

    /*
     * @dev Returns the first rune in the slice, advancing the slice to point
     *      to the next rune.
     * @param self The slice to operate on.
     * @return A slice containing only the first rune from `self`.
     */
    function nextRune(slice memory self) internal pure returns (slice memory ret) {
        nextRune(self, ret);
    }

    /*
     * @dev Returns the number of the first codepoint in the slice.
     * @param self The slice to operate on.
     * @return The number of the first codepoint in the slice.
     */
    function ord(slice memory self) internal pure returns (uint ret) {
        if (self._len == 0) {
            return 0;
        }

        uint word;
        uint length;
        uint divisor = 2 ** 248;

        // Load the rune into the MSBs of b
        assembly { word:= mload(mload(add(self, 32))) }
        uint b = word / divisor;
        if (b < 0x80) {
            ret = b;
            length = 1;
        } else if(b < 0xE0) {
            ret = b & 0x1F;
            length = 2;
        } else if(b < 0xF0) {
            ret = b & 0x0F;
            length = 3;
        } else {
            ret = b & 0x07;
            length = 4;
        }

        // Check for truncated codepoints
        if (length > self._len) {
            return 0;
        }

        for (uint i = 1; i < length; i++) {
            divisor = divisor / 256;
            b = (word / divisor) & 0xFF;
            if (b & 0xC0 != 0x80) {
                // Invalid UTF-8 sequence
                return 0;
            }
            ret = (ret * 64) | (b & 0x3F);
        }

        return ret;
    }

    /*
     * @dev Returns the keccak-256 hash of the slice.
     * @param self The slice to hash.
     * @return The hash of the slice.
     */
    function keccak(slice memory self) internal pure returns (bytes32 ret) {
        assembly {
            ret := keccak256(mload(add(self, 32)), mload(self))
        }
    }

    /*
     * @dev Returns true if `self` starts with `needle`.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return True if the slice starts with the provided text, false otherwise.
     */
    function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
        if (self._len < needle._len) {
            return false;
        }

        if (self._ptr == needle._ptr) {
            return true;
        }

        bool equal;
        assembly {
            let length := mload(needle)
            let selfptr := mload(add(self, 0x20))
            let needleptr := mload(add(needle, 0x20))
            equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
        }
        return equal;
    }

    /*
     * @dev If `self` starts with `needle`, `needle` is removed from the
     *      beginning of `self`. Otherwise, `self` is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return `self`
     */
    function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
        if (self._len < needle._len) {
            return self;
        }

        bool equal = true;
        if (self._ptr != needle._ptr) {
            assembly {
                let length := mload(needle)
                let selfptr := mload(add(self, 0x20))
                let needleptr := mload(add(needle, 0x20))
                equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
            }
        }

        if (equal) {
            self._len -= needle._len;
            self._ptr += needle._len;
        }

        return self;
    }

    /*
     * @dev Returns true if the slice ends with `needle`.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return True if the slice starts with the provided text, false otherwise.
     */
    function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
        if (self._len < needle._len) {
            return false;
        }

        uint selfptr = self._ptr + self._len - needle._len;

        if (selfptr == needle._ptr) {
            return true;
        }

        bool equal;
        assembly {
            let length := mload(needle)
            let needleptr := mload(add(needle, 0x20))
            equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
        }

        return equal;
    }

    /*
     * @dev If `self` ends with `needle`, `needle` is removed from the
     *      end of `self`. Otherwise, `self` is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return `self`
     */
    function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
        if (self._len < needle._len) {
            return self;
        }

        uint selfptr = self._ptr + self._len - needle._len;
        bool equal = true;
        if (selfptr != needle._ptr) {
            assembly {
                let length := mload(needle)
                let needleptr := mload(add(needle, 0x20))
                equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
            }
        }

        if (equal) {
            self._len -= needle._len;
        }

        return self;
    }

    // Returns the memory address of the first byte of the first occurrence of
    // `needle` in `self`, or the first byte after `self` if not found.
    function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr = selfptr;
        uint idx;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                uint end = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr >= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }

    // Returns the memory address of the first byte after the last occurrence of
    // `needle` in `self`, or the address of `self` if not found.
    function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                ptr = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr <= selfptr)
                        return selfptr;
                    ptr--;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr + needlelen;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }
                ptr = selfptr + (selflen - needlelen);
                while (ptr >= selfptr) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr + needlelen;
                    ptr -= 1;
                }
            }
        }
        return selfptr;
    }

    /*
     * @dev Modifies `self` to contain everything from the first occurrence of
     *      `needle` to the end of the slice. `self` is set to the empty slice
     *      if `needle` is not found.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return `self`.
     */
    function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
        self._len -= ptr - self._ptr;
        self._ptr = ptr;
        return self;
    }

    /*
     * @dev Modifies `self` to contain the part of the string from the start of
     *      `self` to the end of the first occurrence of `needle`. If `needle`
     *      is not found, `self` is set to the empty slice.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return `self`.
     */
    function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
        uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
        self._len = ptr - self._ptr;
        return self;
    }

    /*
     * @dev Splits the slice, setting `self` to everything after the first
     *      occurrence of `needle`, and `token` to everything before it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and `token` is set to the entirety of `self`.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @param token An output parameter to which the first token is written.
     * @return `token`.
     */
    function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
        token._ptr = self._ptr;
        token._len = ptr - self._ptr;
        if (ptr == self._ptr + self._len) {
            // Not found
            self._len = 0;
        } else {
            self._len -= token._len + needle._len;
            self._ptr = ptr + needle._len;
        }
        return token;
    }

    /*
     * @dev Splits the slice, setting `self` to everything after the first
     *      occurrence of `needle`, and returning everything before it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and the entirety of `self` is returned.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @return The part of `self` up to the first occurrence of `delim`.
     */
    function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
        split(self, needle, token);
    }

    /*
     * @dev Splits the slice, setting `self` to everything before the last
     *      occurrence of `needle`, and `token` to everything after it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and `token` is set to the entirety of `self`.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @param token An output parameter to which the first token is written.
     * @return `token`.
     */
    function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
        uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
        token._ptr = ptr;
        token._len = self._len - (ptr - self._ptr);
        if (ptr == self._ptr) {
            // Not found
            self._len = 0;
        } else {
            self._len -= token._len + needle._len;
        }
        return token;
    }

    /*
     * @dev Splits the slice, setting `self` to everything before the last
     *      occurrence of `needle`, and returning everything after it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and the entirety of `self` is returned.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @return The part of `self` after the last occurrence of `delim`.
     */
    function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
        rsplit(self, needle, token);
    }

    /*
     * @dev Counts the number of nonoverlapping occurrences of `needle` in `self`.
     * @param self The slice to search.
     * @param needle The text to search for in `self`.
     * @return The number of occurrences of `needle` found in `self`.
     */
    function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
        while (ptr <= self._ptr + self._len) {
            cnt++;
            ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
        }
    }

    /*
     * @dev Returns True if `self` contains `needle`.
     * @param self The slice to search.
     * @param needle The text to search for in `self`.
     * @return True if `needle` is found in `self`, false otherwise.
     */
    function contains(slice memory self, slice memory needle) internal pure returns (bool) {
        return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
    }

    /*
     * @dev Returns a newly allocated string containing the concatenation of
     *      `self` and `other`.
     * @param self The first slice to concatenate.
     * @param other The second slice to concatenate.
     * @return The concatenation of the two strings.
     */
    function concat(slice memory self, slice memory other) internal pure returns (string memory) {
        string memory ret = new string(self._len + other._len);
        uint retptr;
        assembly { retptr := add(ret, 32) }
        memcpy(retptr, self._ptr, self._len);
        memcpy(retptr + self._len, other._ptr, other._len);
        return ret;
    }

    /*
     * @dev Joins an array of slices, using `self` as a delimiter, returning a
     *      newly allocated string.
     * @param self The delimiter to use.
     * @param parts A list of slices to join.
     * @return A newly allocated string containing all the slices in `parts`,
     *         joined with `self`.
     */
    function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {
        if (parts.length == 0)
            return "";

        uint length = self._len * (parts.length - 1);
        for(uint i = 0; i < parts.length; i++)
            length += parts[i]._len;

        string memory ret = new string(length);
        uint retptr;
        assembly { retptr := add(ret, 32) }

        for(uint i = 0; i < parts.length; i++) {
            memcpy(retptr, parts[i]._ptr, parts[i]._len);
            retptr += parts[i]._len;
            if (i < parts.length - 1) {
                memcpy(retptr, self._ptr, self._len);
                retptr += self._len;
            }
        }

        return ret;
    }
}

// Taken from Argent's code base - https://github.com/argentlabs/argent-contracts/blob/develop/contracts/ens/ENS.sol
// with few modifications.



/**
 * ENS Registry interface.
 */
interface ENSRegistry {
    // Logged when the owner of a node assigns a new owner to a subnode.
    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);

    // Logged when the owner of a node transfers ownership to a new account.
    event Transfer(bytes32 indexed node, address owner);

    // Logged when the resolver for a node changes.
    event NewResolver(bytes32 indexed node, address resolver);

    // Logged when the TTL of a node changes
    event NewTTL(bytes32 indexed node, uint64 ttl);

    function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external;
    function setResolver(bytes32 node, address resolver) external;
    function setOwner(bytes32 node, address owner) external;
    function setTTL(bytes32 node, uint64 ttl) external;
    function owner(bytes32 node) external view returns (address);
    function resolver(bytes32 node) external view returns (address);
    function ttl(bytes32 node) external view returns (uint64);
}


/**
 * ENS Resolver interface.
 */
abstract contract ENSResolver {
    function addr(bytes32 _node) public view virtual returns (address);
    function setAddr(bytes32 _node, address _addr) public virtual;
    function name(bytes32 _node) public view virtual returns (string memory);
    function setName(bytes32 _node, string memory _name) public virtual;
}

/**
 * ENS Reverse Registrar interface.
 */
abstract contract ENSReverseRegistrar {
    function claim(address _owner) public virtual returns (bytes32 _node);
    function claimWithResolver(address _owner, address _resolver) public virtual returns (bytes32);
    function setName(string memory _name) public virtual returns (bytes32);
    function node(address _addr) public view virtual returns (bytes32);
}

// Copyright 2017 Loopring Technology Limited.



/// @title Utility Functions for uint
/// @author Daniel Wang - <[email protected]>
library MathUint
{
    function mul(
        uint a,
        uint b
        )
        internal
        pure
        returns (uint c)
    {
        c = a * b;
        require(a == 0 || c / a == b, "MUL_OVERFLOW");
    }

    function sub(
        uint a,
        uint b
        )
        internal
        pure
        returns (uint)
    {
        require(b <= a, "SUB_UNDERFLOW");
        return a - b;
    }

    function add(
        uint a,
        uint b
        )
        internal
        pure
        returns (uint c)
    {
        c = a + b;
        require(c >= a, "ADD_OVERFLOW");
    }
}

// Copyright 2017 Loopring Technology Limited.

pragma experimental ABIEncoderV2;


//Mainly taken from https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol


library BytesUtil {
    function slice(
        bytes memory _bytes,
        uint _start,
        uint _length
    )
        internal
        pure
        returns (bytes memory)
    {
        require(_bytes.length >= (_start + _length));

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint _start) internal  pure returns (address) {
        require(_bytes.length >= (_start + 20));
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint8(bytes memory _bytes, uint _start) internal  pure returns (uint8) {
        require(_bytes.length >= (_start + 1));
        uint8 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x1), _start))
        }

        return tempUint;
    }

    function toUint16(bytes memory _bytes, uint _start) internal  pure returns (uint16) {
        require(_bytes.length >= (_start + 2));
        uint16 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x2), _start))
        }

        return tempUint;
    }

    function toUint24(bytes memory _bytes, uint _start) internal  pure returns (uint24) {
        require(_bytes.length >= (_start + 3));
        uint24 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x3), _start))
        }

        return tempUint;
    }

    function toUint32(bytes memory _bytes, uint _start) internal  pure returns (uint32) {
        require(_bytes.length >= (_start + 4));
        uint32 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x4), _start))
        }

        return tempUint;
    }

    function toUint64(bytes memory _bytes, uint _start) internal  pure returns (uint64) {
        require(_bytes.length >= (_start + 8));
        uint64 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x8), _start))
        }

        return tempUint;
    }

    function toUint96(bytes memory _bytes, uint _start) internal  pure returns (uint96) {
        require(_bytes.length >= (_start + 12));
        uint96 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0xc), _start))
        }

        return tempUint;
    }

    function toUint128(bytes memory _bytes, uint _start) internal  pure returns (uint128) {
        require(_bytes.length >= (_start + 16));
        uint128 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x10), _start))
        }

        return tempUint;
    }

    function toUint(bytes memory _bytes, uint _start) internal  pure returns (uint256) {
        require(_bytes.length >= (_start + 32));
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function toBytes4(bytes memory _bytes, uint _start) internal  pure returns (bytes4) {
        require(_bytes.length >= (_start + 4));
        bytes4 tempBytes4;

        assembly {
            tempBytes4 := mload(add(add(_bytes, 0x20), _start))
        }

        return tempBytes4;
    }

    function toBytes32(bytes memory _bytes, uint _start) internal  pure returns (bytes32) {
        require(_bytes.length >= (_start + 32));
        bytes32 tempBytes32;

        assembly {
            tempBytes32 := mload(add(add(_bytes, 0x20), _start))
        }

        return tempBytes32;
    }

    function fastSHA256(
        bytes memory data
        )
        internal
        view
        returns (bytes32)
    {
        bytes32[] memory result = new bytes32[](1);
        bool success;
        assembly {
             let ptr := add(data, 32)
             success := staticcall(sub(gas(), 2000), 2, ptr, mload(data), add(result, 32), 32)
        }
        require(success, "SHA256_FAILED");
        return result[0];
    }
}


// Copyright 2017 Loopring Technology Limited.



/// @title Utility Functions for addresses
/// @author Daniel Wang - <[email protected]>
/// @author Brecht Devos - <[email protected]>
library AddressUtil
{
    using AddressUtil for *;

    function isContract(
        address addr
        )
        internal
        view
        returns (bool)
    {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(addr) }
        return (codehash != 0x0 &&
                codehash != 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470);
    }

    function toPayable(
        address addr
        )
        internal
        pure
        returns (address payable)
    {
        return address(uint160(addr));
    }

    // Works like address.send but with a customizable gas limit
    // Make sure your code is safe for reentrancy when using this function!
    function sendETH(
        address to,
        uint    amount,
        uint    gasLimit
        )
        internal
        returns (bool success)
    {
        if (amount == 0) {
            return true;
        }
        address payable recipient = to.toPayable();
        /* solium-disable-next-line */
        (success,) = recipient.call{value: amount, gas: gasLimit}("");
    }

    // Works like address.transfer but with a customizable gas limit
    // Make sure your code is safe for reentrancy when using this function!
    function sendETHAndVerify(
        address to,
        uint    amount,
        uint    gasLimit
        )
        internal
        returns (bool success)
    {
        success = to.sendETH(amount, gasLimit);
        require(success, "TRANSFER_FAILURE");
    }
}




/// @title SignatureUtil
/// @author Daniel Wang - <[email protected]>
/// @dev This method supports multihash standard. Each signature's first byte indicates
///      the signature's type, the second byte indicates the signature's length, therefore,
///      each signature will have 2 extra bytes prefix. Mulitple signatures are concatenated
///      together.
library SignatureUtil
{
    using BytesUtil     for bytes;
    using MathUint      for uint;
    using AddressUtil   for address;

    enum SignatureType {
        ILLEGAL,
        INVALID,
        EIP_712,
        ETH_SIGN,
        WALLET   // deprecated
    }

    bytes4 constant internal ERC1271_MAGICVALUE = 0x20c13b0b;

    bytes4 constant internal ERC1271_FUNCTION_WITH_BYTES_SELECTOR = bytes4(
        keccak256(bytes("isValidSignature(bytes,bytes)"))
    );

    bytes4 constant internal ERC1271_FUNCTION_WITH_BYTES32_SELECTOR = bytes4(
        keccak256(bytes("isValidSignature(bytes32,bytes)"))
    );

    function verifySignatures(
        bytes32          signHash,
        address[] memory signers,
        bytes[]   memory signatures
        )
        internal
        view
        returns (bool)
    {
        return verifySignatures(abi.encodePacked(signHash), signers, signatures);
    }

    function verifySignatures(
        bytes     memory data,
        address[] memory signers,
        bytes[]   memory signatures
        )
        internal
        view
        returns (bool)
    {
        require(signers.length == signatures.length, "BAD_SIGNATURE_DATA");
        address lastSigner;
        for (uint i = 0; i < signers.length; i++) {
            require(signers[i] > lastSigner, "INVALID_SIGNERS_ORDER");
            lastSigner = signers[i];
            if (!verifySignature(data, signers[i], signatures[i])) {
                return false;
            }
        }
        return true;
    }

    function verifySignature(
        bytes   memory data,
        address        signer,
        bytes   memory signature
        )
        internal
        view
        returns (bool)
    {
        return signer.isContract() ?
            verifyERC1271Signature(data, signer, signature) :
            verifyEOASignature(data, signer, signature);
    }

    function verifySignature(
        bytes32        signHash,
        address        signer,
        bytes   memory signature
        )
        internal
        view
        returns (bool)
    {
        return verifySignature(abi.encodePacked(signHash), signer, signature);
    }

    function recoverECDSASigner(
        bytes32      signHash,
        bytes memory signature
        )
        internal
        pure
        returns (address)
    {
        if (signature.length != 65) {
            return address(0);
        }

        bytes32 r;
        bytes32 s;
        uint8   v;
        // we jump 32 (0x20) as the first slot of bytes contains the length
        // we jump 65 (0x41) per signature
        // for v we load 32 bytes ending with v (the first 31 come from s) then apply a mask
        assembly {
            r := mload(add(signature, 0x20))
            s := mload(add(signature, 0x40))
            v := and(mload(add(signature, 0x41)), 0xff)
        }
        // See https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/cryptography/ECDSA.sol
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return address(0);
        }
        if (v == 27 || v == 28) {
            return ecrecover(signHash, v, r, s);
        } else {
            return address(0);
        }
    }

    function recoverECDSASigner(
        bytes memory data,
        bytes memory signature
        )
        internal
        pure
        returns (address addr1, address addr2)
    {
        if (data.length == 32) {
            addr1 = recoverECDSASigner(data.toBytes32(0), signature);
        }
        addr2 = recoverECDSASigner(keccak256(data), signature);
    }

    function verifyEOASignature(
        bytes   memory data,
        address        signer,
        bytes   memory signature
        )
        private
        pure
        returns (bool)
    {
        if (signer == address(0)) {
            return false;
        }

        uint signatureTypeOffset = signature.length.sub(1);
        SignatureType signatureType = SignatureType(signature.toUint8(signatureTypeOffset));

        bytes memory stripped = signature.slice(0, signatureTypeOffset);

        if (signatureType == SignatureType.EIP_712) {
            (address addr1, address addr2) = recoverECDSASigner(data, stripped);
            return addr1 == signer || addr2 == signer;
        } else if (signatureType == SignatureType.ETH_SIGN) {
            if (data.length == 32) {
                bytes32 hash = keccak256(
                    abi.encodePacked("\x19Ethereum Signed Message:\n32", data.toBytes32(0))
                );
                if (recoverECDSASigner(hash, stripped) == signer) {
                    return true;
                }
            }
            bytes32 hash = keccak256(
                abi.encodePacked("\x19Ethereum Signed Message:\n32", keccak256(data))
            );
            return recoverECDSASigner(hash, stripped) == signer;
        } else {
            return false;
        }
    }

    function verifyERC1271Signature(
        bytes   memory data,
        address signer,
        bytes   memory signature
        )
        private
        view
        returns (bool)
    {
        return data.length == 32 &&
            verifyERC1271WithBytes32(data.toBytes32(0), signer, signature) ||
            verifyERC1271WithBytes(data, signer, signature);
    }

    function verifyERC1271WithBytes(
        bytes   memory data,
        address signer,
        bytes   memory signature
        )
        private
        view
        returns (bool)
    {
        bytes memory callData = abi.encodeWithSelector(
            ERC1271_FUNCTION_WITH_BYTES_SELECTOR,
            data,
            signature
        );
        (bool success, bytes memory result) = signer.staticcall(callData);
        return (
            success &&
            result.length == 32 &&
            result.toBytes4(0) == ERC1271_MAGICVALUE
        );
    }

    function verifyERC1271WithBytes32(
        bytes32 hash,
        address signer,
        bytes   memory signature
        )
        private
        view
        returns (bool)
    {
        bytes memory callData = abi.encodeWithSelector(
            ERC1271_FUNCTION_WITH_BYTES32_SELECTOR,
            hash,
            signature
        );
        (bool success, bytes memory result) = signer.staticcall(callData);
        return (
            success &&
            result.length == 32 &&
            result.toBytes4(0) == ERC1271_MAGICVALUE
        );
    }
}

// Taken from Argent's code base - https://github.com/argentlabs/argent-contracts/blob/develop/contracts/ens/ENSConsumer.sol
// with few modifications.





/**
 * @title ENSConsumer
 * @dev Helper contract to resolve ENS names.
 * @author Julien Niset - <[email protected]>
 */
contract ENSConsumer {

    using strings for *;

    // namehash('addr.reverse')
    bytes32 constant public ADDR_REVERSE_NODE = 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2;

    // the address of the ENS registry
    address ensRegistry;

    /**
    * @dev No address should be provided when deploying on Mainnet to avoid storage cost. The
    * contract will use the hardcoded value.
    */
    constructor(address _ensRegistry) {
        ensRegistry = _ensRegistry;
    }

    /**
    * @dev Resolves an ENS name to an address.
    * @param _node The namehash of the ENS name.
    */
    function resolveEns(bytes32 _node) public view returns (address) {
        address resolver = getENSRegistry().resolver(_node);
        return ENSResolver(resolver).addr(_node);
    }

    /**
    * @dev Gets the official ENS registry.
    */
    function getENSRegistry() public view returns (ENSRegistry) {
        return ENSRegistry(ensRegistry);
    }

    /**
    * @dev Gets the official ENS reverse registrar.
    */
    function getENSReverseRegistrar() public view returns (ENSReverseRegistrar) {
        return ENSReverseRegistrar(getENSRegistry().owner(ADDR_REVERSE_NODE));
    }
}

// Taken from Argent's code base - https://github.com/argentlabs/argent-contracts/blob/develop/contracts/ens/ArgentENSManager.sol
// with few modifications.






// Copyright 2017 Loopring Technology Limited.




// Copyright 2017 Loopring Technology Limited.





/// @title Claimable
/// @author Brecht Devos - <[email protected]>
/// @dev Extension for the Ownable contract, where the ownership needs
///      to be claimed. This allows the new owner to accept the transfer.
contract Claimable is Ownable
{
    address public pendingOwner;

    /// @dev Modifier throws if called by any account other than the pendingOwner.
    modifier onlyPendingOwner() {
        require(msg.sender == pendingOwner, "UNAUTHORIZED");
        _;
    }

    /// @dev Allows the current owner to set the pendingOwner address.
    /// @param newOwner The address to transfer ownership to.
    function transferOwnership(
        address newOwner
        )
        public
        override
        onlyOwner
    {
        require(newOwner != address(0) && newOwner != owner, "INVALID_ADDRESS");
        pendingOwner = newOwner;
    }

    /// @dev Allows the pendingOwner address to finalize the transfer.
    function claimOwnership()
        public
        onlyPendingOwner
    {
        emit OwnershipTransferred(owner, pendingOwner);
        owner = pendingOwner;
        pendingOwner = address(0);
    }
}



contract OwnerManagable is Claimable, AddressSet
{
    bytes32 internal constant MANAGER = keccak256("__MANAGED__");

    event ManagerAdded  (address manager);
    event ManagerRemoved(address manager);

    modifier onlyManager
    {
        require(isManager(msg.sender), "NOT_MANAGER");
        _;
    }

    modifier onlyOwnerOrManager
    {
        require(msg.sender == owner || isManager(msg.sender), "NOT_OWNER_OR_MANAGER");
        _;
    }

    constructor() Claimable() {}

    /// @dev Gets the managers.
    /// @return The list of managers.
    function managers()
        public
        view
        returns (address[] memory)
    {
        return addressesInSet(MANAGER);
    }

    /// @dev Gets the number of managers.
    /// @return The numer of managers.
    function numManagers()
        public
        view
        returns (uint)
    {
        return numAddressesInSet(MANAGER);
    }

    /// @dev Checks if an address is a manger.
    /// @param addr The address to check.
    /// @return True if the address is a manager, False otherwise.
    function isManager(address addr)
        public
        view
        returns (bool)
    {
        return isAddressInSet(MANAGER, addr);
    }

    /// @dev Adds a new manager.
    /// @param manager The new address to add.
    function addManager(address manager)
        public
        onlyOwner
    {
        addManagerInternal(manager);
    }

    /// @dev Removes a manager.
    /// @param manager The manager to remove.
    function removeManager(address manager)
        public
        onlyOwner
    {
        removeAddressFromSet(MANAGER, manager);
        emit ManagerRemoved(manager);
    }

    function addManagerInternal(address manager)
        internal
    {
        addAddressToSet(MANAGER, manager, true);
        emit ManagerAdded(manager);
    }
}


/**
 * @dev Interface for an ENS Mananger.
 */
interface IENSManager {
    function changeRootnodeOwner(address _newOwner) external;

    function isAvailable(bytes32 _subnode) external view returns (bool);

    function resolveName(address _wallet) external view returns (string memory);

    function register(
        address _wallet,
        address _owner,
        string  calldata _label,
        bytes   calldata _approval
    ) external;
}

/**
 * @title BaseENSManager
 * @dev Implementation of an ENS manager that orchestrates the complete
 * registration of subdomains for a single root (e.g. argent.eth).
 * The contract defines a manager role who is the only role that can trigger the registration of
 * a new subdomain.
 * @author Julien Niset - <[email protected]>
 */
contract BaseENSManager is IENSManager, OwnerManagable, ENSConsumer {

    using strings for *;
    using BytesUtil     for bytes;
    using MathUint      for uint;

    // The managed root name
    string public rootName;
    // The managed root node
    bytes32 public rootNode;
    // The address of the ENS resolver
    address public ensResolver;

    // *************** Events *************************** //

    event RootnodeOwnerChange(bytes32 indexed _rootnode, address indexed _newOwner);
    event ENSResolverChanged(address addr);
    event Registered(address indexed _wallet, address _owner, string _ens);
    event Unregistered(string _ens);

    // *************** Constructor ********************** //

    /**
     * @dev Constructor that sets the ENS root name and root node to manage.
     * @param _rootName The root name (e.g. argentx.eth).
     * @param _rootNode The node of the root name (e.g. namehash(argentx.eth)).
     */
    constructor(string memory _rootName, bytes32 _rootNode, address _ensRegistry, address _ensResolver)
        ENSConsumer(_ensRegistry)
    {
        rootName = _rootName;
        rootNode = _rootNode;
        ensResolver = _ensResolver;
    }

    // *************** External Functions ********************* //

    /**
     * @dev This function must be called when the ENS Manager contract is replaced
     * and the address of the new Manager should be provided.
     * @param _newOwner The address of the new ENS manager that will manage the root node.
     */
    function changeRootnodeOwner(address _newOwner) external override onlyOwner {
        getENSRegistry().setOwner(rootNode, _newOwner);
        emit RootnodeOwnerChange(rootNode, _newOwner);
    }

    /**
     * @dev Lets the owner change the address of the ENS resolver contract.
     * @param _ensResolver The address of the ENS resolver contract.
     */
    function changeENSResolver(address _ensResolver) external onlyOwner {
        require(_ensResolver != address(0), "WF: address cannot be null");
        ensResolver = _ensResolver;
        emit ENSResolverChanged(_ensResolver);
    }

    /**
    * @dev Lets the manager assign an ENS subdomain of the root node to a target address.
    * Registers both the forward and reverse ENS.
    * @param _wallet The wallet which owns the subdomain.
    * @param _owner The wallet's owner.
    * @param _label The subdomain label.
    * @param _approval The signature of _wallet, _owner and _label by a manager.
    */
    function register(
        address _wallet,
        address _owner,
        string  calldata _label,
        bytes   calldata _approval
        )
        external
        override
        onlyManager
    {
        verifyApproval(_wallet, _owner, _label, _approval);

        bytes32 labelNode = keccak256(abi.encodePacked(_label));
        bytes32 node = keccak256(abi.encodePacked(rootNode, labelNode));
        address currentOwner = getENSRegistry().owner(node);
        require(currentOwner == address(0), "AEM: _label is alrealdy owned");

        // Forward ENS
        getENSRegistry().setSubnodeOwner(rootNode, labelNode, address(this));
        getENSRegistry().setResolver(node, ensResolver);
        getENSRegistry().setOwner(node, _wallet);
        ENSResolver(ensResolver).setAddr(node, _wallet);

        // Reverse ENS
        strings.slice[] memory parts = new strings.slice[](2);
        parts[0] = _label.toSlice();
        parts[1] = rootName.toSlice();
        string memory name = ".".toSlice().join(parts);
        bytes32 reverseNode = getENSReverseRegistrar().node(_wallet);
        ENSResolver(ensResolver).setName(reverseNode, name);

        emit Registered(_wallet, _owner, name);
    }

    // *************** Public Functions ********************* //

    /**
    * @dev Resolves an address to an ENS name
    * @param _wallet The ENS owner address
    */
    function resolveName(address _wallet) public view override returns (string memory) {
        bytes32 reverseNode = getENSReverseRegistrar().node(_wallet);
        return ENSResolver(ensResolver).name(reverseNode);
    }

    /**
     * @dev Returns true is a given subnode is available.
     * @param _subnode The target subnode.
     * @return true if the subnode is available.
     */
    function isAvailable(bytes32 _subnode) public view override returns (bool) {
        bytes32 node = keccak256(abi.encodePacked(rootNode, _subnode));
        address currentOwner = getENSRegistry().owner(node);
        if(currentOwner == address(0)) {
            return true;
        }
        return false;
    }

    function verifyApproval(
        address _wallet,
        address _owner,
        string  memory _label,
        bytes   memory _approval
        )
        internal
        view
    {
        bytes32 messageHash = keccak256(
            abi.encodePacked(
                _wallet,
                _owner,
                _label
            )
        );

        bytes32 hash = keccak256(
            abi.encodePacked(
                "\x19Ethereum Signed Message:\n32",
                messageHash
            )
        );

        address signer = SignatureUtil.recoverECDSASigner(hash, _approval);
        require(isManager(signer), "UNAUTHORIZED");
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_rootName","type":"string"},{"internalType":"bytes32","name":"_rootNode","type":"bytes32"},{"internalType":"address","name":"_ensRegistry","type":"address"},{"internalType":"address","name":"_ensResolver","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"}],"name":"ENSResolverChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"manager","type":"address"}],"name":"ManagerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"manager","type":"address"}],"name":"ManagerRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_wallet","type":"address"},{"indexed":false,"internalType":"address","name":"_owner","type":"address"},{"indexed":false,"internalType":"string","name":"_ens","type":"string"}],"name":"Registered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"_rootnode","type":"bytes32"},{"indexed":true,"internalType":"address","name":"_newOwner","type":"address"}],"name":"RootnodeOwnerChange","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_ens","type":"string"}],"name":"Unregistered","type":"event"},{"inputs":[],"name":"ADDR_REVERSE_NODE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"manager","type":"address"}],"name":"addManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_ensResolver","type":"address"}],"name":"changeENSResolver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newOwner","type":"address"}],"name":"changeRootnodeOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ensResolver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getENSRegistry","outputs":[{"internalType":"contract ENSRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getENSReverseRegistrar","outputs":[{"internalType":"contract ENSReverseRegistrar","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_subnode","type":"bytes32"}],"name":"isAvailable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"isManager","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"managers","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numManagers","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"string","name":"_label","type":"string"},{"internalType":"bytes","name":"_approval","type":"bytes"}],"name":"register","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"manager","type":"address"}],"name":"removeManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_node","type":"bytes32"}],"name":"resolveEns","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"}],"name":"resolveName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rootName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rootNode","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000000805c1eee8c1557a09e02b06677face65fb4793bb77c36e84a980a5ba684915362400000000000000000000000000000000000c2e074ec69a0dfb2997ba6c7d2e1e000000000000000000000000f58d55f06bb92f083e78bb5063a2dd3544f9b6a3000000000000000000000000000000000000000000000000000000000000000c6c6f6f7072696e672e6574680000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _rootName (string): loopring.eth
Arg [1] : _rootNode (bytes32): 0x5c1eee8c1557a09e02b06677face65fb4793bb77c36e84a980a5ba6849153624
Arg [2] : _ensRegistry (address): 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e
Arg [3] : _ensResolver (address): 0xF58D55F06bB92f083E78bb5063A2DD3544f9B6a3

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 5c1eee8c1557a09e02b06677face65fb4793bb77c36e84a980a5ba6849153624
Arg [2] : 00000000000000000000000000000000000c2e074ec69a0dfb2997ba6c7d2e1e
Arg [3] : 000000000000000000000000f58d55f06bb92f083e78bb5063a2dd3544f9b6a3
Arg [4] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [5] : 6c6f6f7072696e672e6574680000000000000000000000000000000000000000

54150:5408:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49793:164;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52774:123;;;;;;:::i;:::-;;:::i;:::-;;49605:110;;;:::i;51206:205::-;;;:::i;1335:161::-;;;:::i;52005:140::-;;;:::i;:::-;;;;;;;:::i;56712:1246::-;;;;;;:::i;:::-;;:::i;48803:110::-;;;:::i;:::-;;;;;;;:::i;55714:197::-;;;;;;:::i;:::-;;:::i;58543:320::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;395:20::-;;;:::i;49350:186::-;;;;;;:::i;:::-;;:::i;52985:176::-;;;;;;:::i;:::-;;:::i;54485:26::-;;;:::i;58142:222::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;50506:27::-;;;:::i;52236:134::-;;;:::i;54356:22::-;;;:::i;50879:247::-;;;;;;:::i;:::-;;:::i;52537:147::-;;;;;;:::i;:::-;;:::i;54415:23::-;;;:::i;56084:237::-;;;;;;:::i;:::-;;:::i;49793:164::-;49848:19;49907:16;:14;:16::i;:::-;:41;;-1:-1:-1;;;49907:41:0;;-1:-1:-1;;;;;49907:22:0;;;;;;;:41;;48847:66;;49907:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49880:69;;49793:164;:::o;52774:123::-;841:5;;-1:-1:-1;;;;;841:5:0;827:10;:19;819:44;;;;-1:-1:-1;;;819:44:0;;;;;;;:::i;:::-;;;;;;;;;52862:27:::1;52881:7;52862:18;:27::i;:::-;52774:123:::0;:::o;49605:110::-;49695:11;;-1:-1:-1;;;;;49695:11:0;49605:110;:::o;51206:205::-;50687:12;;-1:-1:-1;;;;;50687:12:0;50673:10;:26;50665:51;;;;-1:-1:-1;;;50665:51:0;;;;;;;:::i;:::-;51323:12:::1;::::0;::::1;51316:5:::0;;51295:41:::1;::::0;-1:-1:-1;;;;;51323:12:0;;::::1;::::0;51316:5;;::::1;::::0;51295:41:::1;::::0;::::1;51355:12;::::0;;::::1;51347:20:::0;;-1:-1:-1;;;;;;51347:20:0;;::::1;-1:-1:-1::0;;;;;51355:12:0;::::1;51347:20;::::0;;;51378:25:::1;::::0;;51206:205::o;1335:161::-;841:5;;-1:-1:-1;;;;;841:5:0;827:10;:19;819:44;;;;-1:-1:-1;;;819:44:0;;;;;;;:::i;:::-;1456:1:::1;1441:5:::0;;1420:39:::1;::::0;-1:-1:-1;;;;;1441:5:0;;::::1;::::0;1420:39:::1;::::0;1456:1;;1420:39:::1;1486:1;1470:18:::0;;-1:-1:-1;;;;;;1470:18:0::1;::::0;;1335:161::o;52005:140::-;52073:16;52114:23;-1:-1:-1;;;;;;;;;;;52114:14:0;:23::i;56712:1246::-;51683:21;51693:10;51683:9;:21::i;:::-;51675:45;;;;-1:-1:-1;;;51675:45:0;;;;;;;:::i;:::-;56936:50:::1;56951:7;56960:6;56968;;56936:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;56936:50:0::1;::::0;;::::1;;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;;;-1:-1:-1;56976:9:0;;-1:-1:-1;56976:9:0;;;;56936:50;::::1;56976:9:::0;;;;56936:50;::::1;;::::0;::::1;::::0;;;;-1:-1:-1;56936:14:0::1;::::0;-1:-1:-1;;;56936:50:0:i:1;:::-;56999:17;57046:6;;57029:24;;;;;;;;;:::i;:::-;;;;;;;;;;;;;57019:35;;;;;;56999:55;;57065:12;57107:8;;57117:9;57090:37;;;;;;;;;:::i;:::-;;;;;;;;;;;;;57080:48;;;;;;57065:63;;57139:20;57162:16;:14;:16::i;:::-;-1:-1:-1::0;;;;;57162:22:0::1;;57185:4;57162:28;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57139:51:::0;-1:-1:-1;;;;;;57209:26:0;::::1;::::0;57201:68:::1;;;;-1:-1:-1::0;;;57201:68:0::1;;;;;;;:::i;:::-;57306:16;:14;:16::i;:::-;-1:-1:-1::0;;;;;57306:32:0::1;;57339:8;;57349:9;57368:4;57306:68;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;57385:16;:14;:16::i;:::-;57420:11;::::0;57385:47:::1;::::0;-1:-1:-1;;;57385:47:0;;-1:-1:-1;;;;;57385:28:0;;::::1;::::0;::::1;::::0;:47:::1;::::0;57414:4;;57420:11;;::::1;::::0;57385:47:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;57443:16;:14;:16::i;:::-;-1:-1:-1::0;;;;;57443:25:0::1;;57469:4;57475:7;57443:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;57506:11:0::1;::::0;57494:47:::1;::::0;-1:-1:-1;;;57494:47:0;;-1:-1:-1;;;;;57506:11:0;;::::1;::::0;-1:-1:-1;57494:32:0::1;::::0;-1:-1:-1;57494:47:0::1;::::0;57527:4;;57533:7;;57494:47:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;57609:22:0::1;::::0;;57629:1:::1;57609:22:::0;;;57578:28:::1;57609:22:::0;;::::1;::::0;;;57578:28;;-1:-1:-1;57609:22:0;-1:-1:-1;57609:22:0::1;;;;;;:::i;:::-;;;;;;;;;;;;;;;;57578:53;;57653:16;:6;;:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;57653:14:0::1;::::0;-1:-1:-1;;;57653:16:0:i:1;:::-;57642:5;57648:1;57642:8;;;;;;;;;::::0;;::::1;::::0;;;;;;:27;;;;57691:8:::1;:16:::0;;::::1;::::0;;::::1;;::::0;::::1;;;;-1:-1:-1::0;;57691:16:0;;;::::1;::::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;;:18:::1;::::0;:16;;:8;:16;::::1;:8:::0;:16;;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:18::i;:::-;57680:5;57686:1;57680:8;;;;;;;;;;;;;:29;;;;57720:18;57741:25;57760:5;57741:13;:11;;;;;;;;;;;;;-1:-1:-1::0;;;57741:11:0::1;;::::0;::::1;:13::i;:::-;:18:::0;::::1;:25::i;:::-;57720:46;;57777:19;57799:24;:22;:24::i;:::-;-1:-1:-1::0;;;;;57799:29:0::1;;57829:7;57799:38;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57860:11;::::0;57848:51:::1;::::0;-1:-1:-1;;;57848:51:0;;57777:60;;-1:-1:-1;;;;;;57860:11:0::1;::::0;57848:32:::1;::::0;:51:::1;::::0;57777:60;;57894:4;;57848:51:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;57928:7;-1:-1:-1::0;;;;;57917:33:0::1;;57937:6;57945:4;57917:33;;;;;;;:::i;:::-;;;;;;;;51731:1;;;;;;56712:1246:::0;;;;;;:::o;48803:110::-;48847:66;48803:110;:::o;55714:197::-;841:5;;-1:-1:-1;;;;;841:5:0;827:10;:19;819:44;;;;-1:-1:-1;;;819:44:0;;;;;;;:::i;:::-;55801:16:::1;:14;:16::i;:::-;-1:-1:-1::0;;;;;55801:25:0::1;;55827:8;;55837:9;55801:46;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;55893:9;-1:-1:-1::0;;;;;55863:40:0::1;55883:8;;55863:40;;;;;;;;;;55714:197:::0;:::o;58543:320::-;58612:4;58629:12;58671:8;;58681;58654:36;;;;;;;;;:::i;:::-;;;;;;;;;;;;;58644:47;;;;;;58629:62;;58702:20;58725:16;:14;:16::i;:::-;-1:-1:-1;;;;;58725:22:0;;58748:4;58725:28;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58702:51;-1:-1:-1;;;;;;58767:26:0;;58764:69;;58817:4;58810:11;;;;;;58764:69;58850:5;58843:12;;;;58543:320;;;;:::o;395:20::-;;;-1:-1:-1;;;;;395:20:0;;:::o;49350:186::-;49406:7;49426:16;49445;:14;:16::i;:::-;-1:-1:-1;;;;;49445:25:0;;49471:5;49445:32;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49495:33;;-1:-1:-1;;;49495:33:0;;49426:51;;-1:-1:-1;;;;;;49495:26:0;;;;;:33;;49522:5;;49495:33;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49488:40;49350:186;-1:-1:-1;;;49350:186:0:o;52985:176::-;841:5;;-1:-1:-1;;;;;841:5:0;827:10;:19;819:44;;;;-1:-1:-1;;;819:44:0;;;;;;;:::i;:::-;53076:38:::1;-1:-1:-1::0;;;;;;;;;;;53106:7:0::1;53076:20;:38::i;:::-;53130:23;53145:7;53130:23;;;;;;:::i;:::-;;;;;;;;52985:176:::0;:::o;54485:26::-;;;-1:-1:-1;;;;;54485:26:0;;:::o;58142:222::-;58210:13;58236:19;58258:24;:22;:24::i;:::-;-1:-1:-1;;;;;58258:29:0;;58288:7;58258:38;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58326:11;;58314:42;;-1:-1:-1;;;58314:42:0;;58236:60;;-1:-1:-1;;;;;;58326:11:0;;58314:29;;:42;;58236:60;;58314:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;58314:42:0;;;;;;;;;;;;:::i;50506:27::-;;;-1:-1:-1;;;;;50506:27:0;;:::o;52236:134::-;52307:4;52336:26;-1:-1:-1;;;;;;;;;;;52336:17:0;:26::i;54356:22::-;;;;;;;;;;;;;;;-1:-1:-1;;54356:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;50879:247::-;841:5;;-1:-1:-1;;;;;841:5:0;827:10;:19;819:44;;;;-1:-1:-1;;;819:44:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;51021:22:0;::::1;::::0;;::::1;::::0;:43:::1;;-1:-1:-1::0;51059:5:0::1;::::0;-1:-1:-1;;;;;51047:17:0;;::::1;51059:5:::0;::::1;51047:17;;51021:43;51013:71;;;;-1:-1:-1::0;;;51013:71:0::1;;;;;;;:::i;:::-;51095:12;:23:::0;;-1:-1:-1;;;;;;51095:23:0::1;-1:-1:-1::0;;;;;51095:23:0;;;::::1;::::0;;;::::1;::::0;;50879:247::o;52537:147::-;52618:4;52647:29;-1:-1:-1;;;;;;;;;;;52671:4:0;52647:14;:29::i;:::-;52640:36;52537:147;-1:-1:-1;;52537:147:0:o;54415:23::-;;;;:::o;56084:237::-;841:5;;-1:-1:-1;;;;;841:5:0;827:10;:19;819:44;;;;-1:-1:-1;;;819:44:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;56171:26:0;::::1;56163:65;;;;-1:-1:-1::0;;;56163:65:0::1;;;;;;;:::i;:::-;56239:11;:26:::0;;-1:-1:-1;;;;;;56239:26:0::1;-1:-1:-1::0;;;;;56239:26:0;::::1;;::::0;;56281:32:::1;::::0;::::1;::::0;::::1;::::0;56239:26;;56281:32:::1;:::i;53169:163::-:0;53248:39;-1:-1:-1;;;;;;;;;;;53273:7:0;53282:4;53248:15;:39::i;:::-;53303:21;53316:7;53303:21;;;;;;:::i;3485:264::-;3606:15;3624:9;;;:4;:9;;;;;;;;3665:20;;3652:9;;;;3572:16;;3652:33;3644:60;;;;-1:-1:-1;;;3644:60:0;;;;;;;:::i;:::-;3722:9;;;;:4;:9;;;;;;;;;3715:26;;;;;;;;;;;;;;;;;3722:9;;3715:26;;3722:9;3715:26;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;3715:26:0;;;;;;;;;;;;;;;;;;;;;;;;3485:264;;;:::o;58871:682::-;59072:19;59153:7;59179:6;59204;59118:107;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;59094:142;;;;;;59072:164;;59249:12;59376:11;59288:114;;;;;;;;:::i;:::-;;;;;;;;;;;;;59264:149;;;;;;59249:164;;59426:14;59443:49;59476:4;59482:9;59443:32;:49::i;:::-;59426:66;;59511:17;59521:6;59511:9;:17::i;:::-;59503:42;;;;-1:-1:-1;;;59503:42:0;;;;;;;:::i;:::-;58871:682;;;;;;;:::o;6657:216::-;6717:12;;:::i;:::-;-1:-1:-1;6835:30:0;;;;;;;;;6841:18;;6835:30;;6802:4;6792:15;;;6835:30;;;;6657:216;;;:::o;29134:750::-;29212:13;29242:5;:12;29258:1;29242:17;29238:45;;;-1:-1:-1;29274:9:0;;;;;;;;;-1:-1:-1;29274:9:0;;;;29238:45;29323:12;;29310:9;;-1:-1:-1;;29323:16:0;;;29310:30;29296:11;29351:75;29371:5;:12;29367:1;:16;29351:75;;;29413:5;29419:1;29413:8;;;;;;;;;;;;;;;;;;:13;29403:23;;;;;29385:3;;29351:75;;;;29439:17;29470:6;29459:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;29459:18:0;-1:-1:-1;29439:38:0;-1:-1:-1;29540:2:0;29531:12;;29488:11;29557:297;29577:5;:12;29573:1;:16;29557:297;;;29611:44;29618:6;29626:5;29632:1;29626:8;;;;;;;;;;;;;;:13;;;29641:5;29647:1;29641:8;;;;;;;;;;;;;;:13;;;29611:6;:44::i;:::-;29680:5;29686:1;29680:8;;;;;;;;;;;;;;:13;;;29670:23;;;;29731:1;29716:5;:12;:16;29712:1;:20;29708:135;;;29753:36;29760:6;29768:4;:9;;;29779:4;:9;;;29753:6;:36::i;:::-;29818:9;;29808:19;;;;;29708:135;29591:3;;29557:297;;;-1:-1:-1;29873:3:0;;29134:750;-1:-1:-1;;;;;29134:750:0:o;2392:600::-;2512:15;2530:9;;;:4;:9;;;;;;;;-1:-1:-1;;;;;2561:19:0;;;;:13;;;:19;;;;;;;2599:8;2591:31;;;;-1:-1:-1;;;2591:31:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2642:19:0;;;;;;:13;;;:19;;;;;2635:26;2672:9;;;:14;;-1:-1:-1;;2672:14:0;;;2703:20;;:24;2699:286;;2744:16;2763:3;:13;;2777:3;:9;;;2763:24;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2763:24:0;;;;-1:-1:-1;2806:16:0;;;;2802:138;;2868:8;2843:3;:13;;2863:1;2857:3;:7;2843:22;;;;;;;;;;;;;;;;;;;;:33;;-1:-1:-1;;;;;;2843:33:0;-1:-1:-1;;;;;2843:33:0;;;;;;2895:23;;;;;-1:-1:-1;2895:13:0;;:23;;;;;;:29;;;2802:138;2954:19;;:3;;:19;;;;;;;;;;;;;;-1:-1:-1;;2954:19:0;;;;;-1:-1:-1;;;;;;2954:19:0;;;;;;-1:-1:-1;2699:286:0;2392:600;;;;:::o;3303:174::-;3393:4;3433:9;;;:4;:9;;;;;;;;3460;;;3303:174::o;3098:197::-;3228:4;3257:9;;;:4;:9;;;;;;;;-1:-1:-1;;;;;3257:25:0;;;;:19;;:25;;;;;;:30;;3098:197;;;;:::o;1830:554::-;1967:15;1985:9;;;:4;:9;;;;;;;;-1:-1:-1;;;;;2013:19:0;;;;:13;;;:19;;;;;;;:24;2005:51;;;;-1:-1:-1;;;2005:51:0;;;;;;;:::i;:::-;2073:12;2069:239;;;2134:9;;;;2110:20;;:33;2102:71;;;;-1:-1:-1;;;2102:71:0;;;;;;;:::i;:::-;2188:24;;;;;;;-1:-1:-1;2188:24:0;;;;;;;;;-1:-1:-1;;;;;;2188:24:0;-1:-1:-1;;;;;2188:24:0;;;;;2069:239;;;2253:20;;:25;2245:51;;;;-1:-1:-1;;;2245:51:0;;;;;;;:::i;:::-;2320:9;;;:14;;2333:1;2320:14;;;;;;;-1:-1:-1;;;;;2345:19:0;;;2320:9;2345:19;;;:13;;;;:19;;;;;:31;;;;-1:-1:-1;;1830:554:0:o;43978:1116::-;44132:7;44161:9;:16;44181:2;44161:22;44157:72;;-1:-1:-1;44215:1:0;44200:17;;44157:72;44566:4;44551:20;;44545:27;44612:4;44597:20;;44591:27;44662:4;44647:20;;44641:27;44670:4;44637:38;44829:66;44816:79;;44812:129;;;44927:1;44912:17;;;;;;;44812:129;44955:1;:7;;44960:2;44955:7;:18;;;;44966:1;:7;;44971:2;44966:7;44955:18;44951:136;;;44997:28;45007:8;45017:1;45020;45023;44997:28;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44990:35;;;;;;;44951:136;45073:1;45058:17;;;;;;;5885:565;6007:170;6020:2;6013:3;:9;6007:170;;6091:10;;6078:24;;6139:2;6131:10;;;;6156:9;;;;-1:-1:-1;;6024:9:0;6007:170;;;6309:10;;6365:11;;6242:2;:8;;;;6234:3;:17;-1:-1:-1;;6234:21:0;6321:9;;6305:26;;;6361:22;;6410:21;6397:35;;6275:168::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;:::o;575:336::-;;;689:3;682:4;674:6;670:17;666:27;656:2;;-1:-1;;697:12;656:2;-1:-1;727:20;;767:18;756:30;;753:2;;;-1:-1;;789:12;753:2;833:4;825:6;821:17;809:29;;884:3;833:4;864:17;825:6;850:32;;847:41;844:2;;;901:1;;891:12;844:2;649:262;;;;;:::o;1732:241::-;;1836:2;1824:9;1815:7;1811:23;1807:32;1804:2;;;-1:-1;;1842:12;1804:2;85:6;72:20;97:33;124:5;97:33;:::i;1980:263::-;;2095:2;2083:9;2074:7;2070:23;2066:32;2063:2;;;-1:-1;;2101:12;2063:2;226:6;220:13;238:33;265:5;238:33;:::i;2250:867::-;;;;;;;2444:3;2432:9;2423:7;2419:23;2415:33;2412:2;;;-1:-1;;2451:12;2412:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2503:63;-1:-1;2603:2;2642:22;;72:20;97:33;72:20;97:33;:::i;:::-;2611:63;-1:-1;2739:2;2724:18;;2711:32;2763:18;2752:30;;;2749:2;;;-1:-1;;2785:12;2749:2;2823:65;2880:7;2871:6;2860:9;2856:22;2823:65;:::i;:::-;2805:83;;-1:-1;2805:83;-1:-1;2953:2;2938:18;;2925:32;;-1:-1;2966:30;;;2963:2;;;-1:-1;;2999:12;2963:2;;3037:64;3093:7;3084:6;3073:9;3069:22;3037:64;:::i;:::-;2406:711;;;;-1:-1;2406:711;;-1:-1;2406:711;;3019:82;;2406:711;-1:-1;;;2406:711::o;3124:241::-;;3228:2;3216:9;3207:7;3203:23;3199:32;3196:2;;;-1:-1;;3234:12;3196:2;-1:-1;350:20;;3190:175;-1:-1;3190:175::o;3372:263::-;;3487:2;3475:9;3466:7;3462:23;3458:32;3455:2;;;-1:-1;;3493:12;3455:2;-1:-1;498:13;;3449:186;-1:-1;3449:186::o;3642:362::-;;3767:2;3755:9;3746:7;3742:23;3738:32;3735:2;;;-1:-1;;3773:12;3735:2;3824:17;3818:24;3862:18;;3854:6;3851:30;3848:2;;;-1:-1;;3884:12;3848:2;3971:6;3960:9;3956:22;;;1393:3;1386:4;1378:6;1374:17;1370:27;1360:2;;-1:-1;;1401:12;1360:2;1441:6;1435:13;3862:18;21803:6;21800:30;21797:2;;;-1:-1;;21833:12;21797:2;21466;21460:9;21906;21887:17;;-1:-1;;21883:33;21492:17;;3767:2;21492:17;21552:34;;;21588:22;;;21549:62;21546:2;;;-1:-1;;21614:12;21546:2;21466;21633:22;1534:21;;;1634:16;;;3767:2;1634:16;1631:25;-1:-1;1628:2;;;-1:-1;;1659:12;1628:2;1679:39;1711:6;3767:2;1610:5;1606:16;3767:2;1576:6;1572:17;1679:39;:::i;:::-;3904:84;3729:275;-1:-1;;;;;;3729:275::o;6409:347::-;;6554:5;22257:12;22673:6;22668:3;22661:19;6648:52;6693:6;22710:4;22705:3;22701:14;22710:4;6674:5;6670:16;6648:52;:::i;:::-;21906:9;25027:14;-1:-1;;25023:28;6712:39;;;;22710:4;6712:39;;6501:255;-1:-1;;6501:255::o;11032:553::-;;25134:14;;;23135:5;25138:2;25134:14;;4519:3;4512:58;25134:14;23135:5;25138:2;25134:14;;11333:2;11328:3;11324:12;4512:58;;6926:5;22257:12;7038:52;7083:6;11435:12;11328:3;11435:12;7071:4;7064:5;7060:16;7038:52;:::i;:::-;7102:16;;;;11435:12;7102:16;;11224:361;-1:-1;;;;11224:361::o;11592:392::-;5493:37;;;11845:2;11836:12;;5493:37;11947:12;;;11736:248::o;11991:295::-;;24331:6;24326:3;24321;24308:30;24369:16;;24362:27;;;24369:16;12137:149;-1:-1;12137:149::o;12293:520::-;7751:66;7731:87;;7715:2;7837:12;;5493:37;;;;12776:12;;;12510:303::o;12820:222::-;-1:-1;;;;;23386:54;;;;4254:37;;12947:2;12932:18;;12918:124::o;13049:421::-;-1:-1;;;;;23386:54;;4254:37;;13224:2;13342;13327:18;;13320:48;;;13049:421;;13382:78;;13209:18;;13446:6;13382:78;:::i;:::-;13374:86;13195:275;-1:-1;;;;13195:275::o;13477:370::-;13654:2;13668:47;;;22257:12;;13639:18;;;22661:19;;;13477:370;;13654:2;22111:14;;;;22701;;;;13477:370;5021:260;5046:6;5043:1;5040:13;5021:260;;;5107:13;;-1:-1;;;;;23386:54;4254:37;;22516:14;;;;4165;;;;767:18;5061:9;5021:260;;;-1:-1;13721:116;;13625:222;-1:-1;;;;;;13625:222::o;13854:210::-;23219:13;;23212:21;5376:34;;13975:2;13960:18;;13946:118::o;14071:222::-;5493:37;;;14198:2;14183:18;;14169:124::o;14300:333::-;5493:37;;;-1:-1;;;;;23386:54;14619:2;14604:18;;4254:37;14455:2;14440:18;;14426:207::o;14640:444::-;5493:37;;;14987:2;14972:18;;5493:37;;;;-1:-1;;;;;23386:54;15070:2;15055:18;;4254:37;14823:2;14808:18;;14794:290::o;15091:421::-;;5523:5;5500:3;5493:37;15266:2;15384;15373:9;15369:18;15362:48;15424:78;15266:2;15255:9;15251:18;15488:6;15424:78;:::i;15519:548::-;5493:37;;;23602:4;23591:16;;;;15887:2;15872:18;;10985:35;15970:2;15955:18;;5493:37;16053:2;16038:18;;5493:37;15726:3;15711:19;;15697:370::o;16628:310::-;;16775:2;16796:17;16789:47;16850:78;16775:2;16764:9;16760:18;16914:6;16850:78;:::i;16945:416::-;17145:2;17159:47;;;7355:2;17130:18;;;22661:19;-1:-1;;;22701:14;;;7371:38;7428:12;;;17116:245::o;17368:416::-;17568:2;17582:47;;;8088:2;17553:18;;;22661:19;-1:-1;;;22701:14;;;8104:35;8158:12;;;17539:245::o;17791:416::-;17991:2;18005:47;;;8409:2;17976:18;;;22661:19;-1:-1;;;22701:14;;;8425:34;8478:12;;;17962:245::o;18214:416::-;18414:2;18428:47;;;8729:2;18399:18;;;22661:19;-1:-1;;;22701:14;;;8745:37;8801:12;;;18385:245::o;18637:416::-;18837:2;18851:47;;;9052:2;18822:18;;;22661:19;-1:-1;;;22701:14;;;9068:36;9123:12;;;18808:245::o;19060:416::-;19260:2;19274:47;;;9374:2;19245:18;;;22661:19;-1:-1;;;22701:14;;;9390:33;9442:12;;;19231:245::o;19483:416::-;19683:2;19697:47;;;9693:2;19668:18;;;22661:19;9729:28;22701:14;;;9709:49;9777:12;;;19654:245::o;19906:416::-;20106:2;20120:47;;;10028:2;20091:18;;;22661:19;10064:31;22701:14;;;10044:52;10115:12;;;20077:245::o;20329:416::-;20529:2;20543:47;;;10366:2;20514:18;;;22661:19;10402:27;22701:14;;;10382:48;10449:12;;;20500:245::o;20752:416::-;20952:2;20966:47;;;10700:2;20937:18;;;22661:19;-1:-1;;;22701:14;;;10716:37;10772:12;;;20923:245::o;24404:268::-;24469:1;24476:101;24490:6;24487:1;24484:13;24476:101;;;24557:11;;;24551:18;24538:11;;;24531:39;24512:2;24505:10;24476:101;;;24592:6;24589:1;24586:13;24583:2;;;-1:-1;;24469:1;24639:16;;24632:27;24453:219::o;25166:117::-;-1:-1;;;;;23386:54;;25225:35;;25215:2;;25274:1;;25264:12

ipfs://27c383b11ae93da7eb7b12164612f47c8a827aa62f4a70e19d749d91b6a3c83b