Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• 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 ...
• library BytesLib
•    - function concat(
•    - function concatStorage(bytes storage ...
•    - function slice(
•    - function toAddress(bytes memory _byte ...
•    - function toUint8(bytes memory _bytes, ...
•    - function toUint16(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 toBytes32(bytes memory _byte ...
•    - function equal(bytes memory _preBytes ...
•    - function equalStorage(
• interface ApproveAndCallFallBack
•    - function receiveApproval(address from ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
•  contract Context
•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•  contract ERC20 is Context, IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _burnFrom(address account, u ...
•  contract ERC20Burnable is Context, ...
•    - function burn(uint256 amount)
•    - function burnFrom(address account, ui ...
• interface ETHFeed
•    - function priceForEtherInUsdWei()
• interface BZNFeed
•    - function convert(uint256 usd)
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•  contract IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(address fro ...
•  contract IGunToken is IERC721
•    - function exists(uint256 tokenId)
•    - function claimAllocation(address to, ...
•  contract GunPreOrder is Ownable, A ... *
•    - function createCategory(uint8 categor ...
•    - function disableCreateCategories()
•    - function toggleETHPayment(bool enable ...
•    - function setCommission(address referr ...
•    - function setPercentIncrease(uint256 i ...
•    - function setEtherPercent(uint256 perc ...
•    - function killCategory(uint8 category)
•    - function setShopState(uint8 category, ...
•    - function setPrice(uint8 category, uin ...
•    - function withdraw(uint256 amount)
•    - function setBZNFeedContract(address n ...
•    - function setEtherFeedContract(address ...
•    - function buyWithBZN(address referal, ...
•    - function buyWithEther(address referal ...
•    - function convert(uint256 usdValue, bo ...
•    - function priceFor(uint8 category, uin ...
•    - function sold(uint256 _tokenId)
•    - function receiveApproval(address from ...
•  contract GunFactory is Ownable
•    - function uintToString(uint v)
•    - function mintFor(address newOwner, ui ...
•    - function hasReachedLimit(uint8 catego ...
•    - function reachedLimit(uint8 category)
•    - function currentLimit(uint8 category)
•    - function setCategoryLimit(uint8 categ ...
•    - function attachPreOrder(address dst)
•    - function attachToken(address dst)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-08-30
*/

pragma solidity ^0.5.17;

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 (uint(self) & 0xffffffffffffffffffffffffffffffff == 0) {
            ret += 16;
            self = bytes32(uint(self) / 0x100000000000000000000000000000000);
        }
        if (uint(self) & 0xffffffffffffffff == 0) {
            ret += 8;
            self = bytes32(uint(self) / 0x10000000000000000);
        }
        if (uint(self) & 0xffffffff == 0) {
            ret += 4;
            self = bytes32(uint(self) / 0x100000000);
        }
        if (uint(self) & 0xffff == 0) {
            ret += 2;
            self = bytes32(uint(self) / 0x10000);
        }
        if (uint(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 know 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;
    }
}

library BytesLib {
    function concat(
        bytes memory _preBytes,
        bytes memory _postBytes
    )
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;

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

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add 
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(0x40, and(
              add(add(end, iszero(add(length, mload(_preBytes)))), 31),
              not(31) // Round down to the nearest 32 bytes.
            ))
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes_slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes_slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes_slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes_slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes_slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes_slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))
                
                for { 
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

    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 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 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 equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for {
                    let cc := add(_postBytes, 0x20)
                // the next line is the loop condition:
                // while(uint(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equalStorage(
        bytes storage _preBytes,
        bytes memory _postBytes
    )
        internal
        view
        returns (bool)
    {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes_slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes_slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint(mc < end) + cb == 2)
                        for {} eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}

interface ApproveAndCallFallBack {
    function receiveApproval(address from, uint256 tokens, address token, bytes calldata data) external payable returns (bool);
}

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas 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 mod(a, b, "SafeMath: modulo by zero");
    }

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


/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @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.
 *
 * 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.
 */
contract Ownable is Context {
    address private _owner;

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

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

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

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

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}



/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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


/**
 * @dev 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 {ERC20Mintable}.
 *
 * 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 guidelines: functions revert instead
 * of 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 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view 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 returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public 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 returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

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

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

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

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

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

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

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

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

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "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 Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }
}


/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev See {ERC20-_burnFrom}.
     */
    function burnFrom(address account, uint256 amount) public {
        _burnFrom(account, amount);
    }
}


interface ETHFeed {
    function priceForEtherInUsdWei() external view returns (uint256);
}

interface BZNFeed {
    /**
     * Returns the converted BZN value
     */
    function convert(uint256 usd) external view returns (uint256);
}

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
contract IERC721 is IERC165 {
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of NFTs in `owner`'s account.
     */
    function balanceOf(address owner) public view returns (uint256 balance);

    /**
     * @dev Returns the owner of the NFT specified by `tokenId`.
     */
    function ownerOf(uint256 tokenId) public view returns (address owner);

    /**
     * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
     * another (`to`).
     *
     *
     *
     * Requirements:
     * - `from`, `to` cannot be zero.
     * - `tokenId` must be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this
     * NFT by either {approve} or {setApprovalForAll}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public;
    /**
     * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
     * another (`to`).
     *
     * Requirements:
     * - If the caller is not `from`, it must be approved to move this NFT by
     * either {approve} or {setApprovalForAll}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public;
    function approve(address to, uint256 tokenId) public;
    function getApproved(uint256 tokenId) public view returns (address operator);

    function setApprovalForAll(address operator, bool _approved) public;
    function isApprovedForAll(address owner, address operator) public view returns (bool);


    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}


contract IGunToken is IERC721 {
    function exists(uint256 tokenId) external view returns (bool);

    function claimAllocation(address to, uint16 size, uint8 category) external returns (uint);
}

contract GunPreOrder is Ownable, ApproveAndCallFallBack {
    using BytesLib for bytes;
    using SafeMath for uint256;
    
    //Event for when a bulk buy order has been placed
    event consumerBulkBuy(uint8 category, uint256 quanity, address reserver);
    //Event for when a gun has been bought
    event GunsBought(uint256 gunId, address owner, uint8 category);
    //Event for when ether is taken out of this contract
    event Withdrawal(uint256 amount);

    //Default referal commision percent
    uint256 public constant COMMISSION_PERCENT = 5;
    
    //Whether category is open
    mapping(uint8 => bool) public categoryExists;
    mapping(uint8 => bool) public categoryOpen;
    mapping(uint8 => bool) public categoryKilled;
    
    //The additional referal commision percent for any given referal address (default is 0)
    mapping(address => uint256) internal commissionRate;
    
    //How many guns in a given category an address has reserved
    mapping(uint8 => mapping(address => uint256)) public categoryReserveAmount;
    
    //Opensea buy address
    address internal constant OPENSEA = 0x5b3256965e7C3cF26E11FCAf296DfC8807C01073;

    //The percent increase and percent base for a given category
    mapping(uint8 => uint256) public categoryPercentIncrease;
    mapping(uint8 => uint256) public categoryPercentBase;

    //Price of a givevn category in USD WEI
    mapping(uint8 => uint256) public categoryPrice;
    
    //The percent of ether required for buying in BZN
    mapping(uint8 => uint256) public requiredEtherPercent;
    mapping(uint8 => uint256) public requiredEtherPercentBase;
    bool public allowCreateCategory = true;
    bool public allowEthPayment = true;

    //The gun token contract
    IGunToken public token;
    //The gun factory contract
    GunFactory internal factory;
    //The BZN contract
    ERC20Burnable internal bzn;
    //The Maker ETH/USD price feed
    ETHFeed public ethFeed;
    BZNFeed public bznFeed;
    //The gamepool address
    address internal gamePool;
    
    //Require the skinned/regular shop to be opened
    modifier ensureShopOpen(uint8 category) {
        require(categoryExists[category], "Category doesn't exist!");
        require(categoryOpen[category], "Category is not open!");
        _;
    }
    
    //Allow a function to accept ETH payment
    modifier payInETH(address referal, uint8 category, address new_owner, uint16 quanity) {
        require(allowEthPayment, "ETH Payments are disabled");
        uint256 usdPrice;
        uint256 totalPrice;
        (usdPrice, totalPrice) = priceFor(category, quanity);
        require(usdPrice > 0, "Price not yet set");
        
        categoryPrice[category] = usdPrice; //Save last price
        
        uint256 price = convert(totalPrice, false);
        
        require(msg.value >= price, "Not enough Ether sent!");
        
        _;
        
        if (msg.value > price) {
            uint256 change = msg.value - price;

            msg.sender.transfer(change);
        }
        
        if (referal != address(0)) {
            require(referal != msg.sender, "The referal cannot be the sender");
            require(referal != tx.origin, "The referal cannot be the tranaction origin");
            require(referal != new_owner, "The referal cannot be the new owner");

            //The commissionRate map adds any partner bonuses, or 0 if a normal user referral
            uint256 totalCommision = COMMISSION_PERCENT + commissionRate[referal];

            uint256 commision = (price * totalCommision) / 100;
            
            address payable _referal = address(uint160(referal));

            _referal.transfer(commision);
        }

    }
    
    //Allow function to accept BZN payment
    modifier payInBZN(address referal, uint8 category, address payable new_owner, uint16 quanity) {
        uint256[] memory prices = new uint256[](4); //Hack to work around local var limit (usdPrice, bznPrice, commision, totalPrice)
        (prices[0], prices[3]) = priceFor(category, quanity);
        require(prices[0] > 0, "Price not yet set");
            
        categoryPrice[category] = prices[0];
        
        prices[1] = convert(prices[3], true); //Convert the totalPrice to BZN

        //The commissionRate map adds any partner bonuses, or 0 if a normal user referral
        if (referal != address(0)) {
            prices[2] = (prices[1] * (COMMISSION_PERCENT + commissionRate[referal])) / 100;
        }
        
        uint256 requiredEther = (convert(prices[3], false) * requiredEtherPercent[category]) / requiredEtherPercentBase[category];
        
        require(msg.value >= requiredEther, "Buying with BZN requires some Ether!");
        
        bzn.burnFrom(new_owner, (((prices[1] - prices[2]) * 30) / 100));
        bzn.transferFrom(new_owner, gamePool, prices[1] - prices[2] - (((prices[1] - prices[2]) * 30) / 100));
        
        _;
        
        if (msg.value > requiredEther) {
            new_owner.transfer(msg.value - requiredEther);
        }
        
        if (referal != address(0)) {
            require(referal != msg.sender, "The referal cannot be the sender");
            require(referal != tx.origin, "The referal cannot be the tranaction origin");
            require(referal != new_owner, "The referal cannot be the new owner");
            
            bzn.transferFrom(new_owner, referal, prices[2]);
            
            prices[2] = (requiredEther * (COMMISSION_PERCENT + commissionRate[referal])) / 100;
            
            address payable _referal = address(uint160(referal));

            _referal.transfer(prices[2]);
        }
    }

    //Constructor
    constructor(
        address tokenAddress,
        address tokenFactory,
        address gp,
        address ethfeed,
        address bzn_address
    ) public {
        token = IGunToken(tokenAddress);

        factory = GunFactory(tokenFactory);
        
        ethFeed = ETHFeed(ethfeed);
        bzn = ERC20Burnable(bzn_address);

        gamePool = gp;

        //Set percent increases
        categoryPercentIncrease[1] = 100035;
        categoryPercentBase[1] = 100000;
        
        categoryPercentIncrease[2] = 100025;
        categoryPercentBase[2] = 100000;
        
        categoryPercentIncrease[3] = 100015;
        categoryPercentBase[3] = 100000;
        
        commissionRate[OPENSEA] = 10;
    }
    
    function createCategory(uint8 category) public onlyOwner {
        require(allowCreateCategory);
        
        categoryExists[category] = true;
    }
    
    function disableCreateCategories() public onlyOwner {
        allowCreateCategory = false;
    }

    function toggleETHPayment(bool enable) public onlyOwner {
        allowEthPayment = enable;
    }
    
    //Set the referal commision rate for an address
    function setCommission(address referral, uint256 percent) public onlyOwner {
        require(percent > COMMISSION_PERCENT);
        require(percent < 95);
        percent = percent - COMMISSION_PERCENT;
        
        commissionRate[referral] = percent;
    }
    
    //Set the price increase/base for skinned or regular guns
    function setPercentIncrease(uint256 increase, uint256 base, uint8 category) public onlyOwner {
        require(increase > base);
        
        categoryPercentIncrease[category] = increase;
        categoryPercentBase[category] = base;
    }
    
    function setEtherPercent(uint256 percent, uint256 base, uint8 category) public onlyOwner {
        requiredEtherPercent[category] = percent;
        requiredEtherPercentBase[category] = base;
    }
    
    function killCategory(uint8 category) public onlyOwner {
        require(!categoryKilled[category]);
        
        categoryOpen[category] = false;
        categoryKilled[category] = true;
    }

    //Open/Close the skinned or regular guns shop
    function setShopState(uint8 category, bool open) public onlyOwner {
        require(category == 1 || category == 2 || category == 3);
        require(!categoryKilled[category]);
        require(categoryExists[category]);
        
        categoryOpen[category] = open;
    }

    /**
     * Set the price for any given category in USD.
     */
    function setPrice(uint8 category, uint256 price, bool inWei) public onlyOwner {
        uint256 multiply = 1e18;
        if (inWei) {
            multiply = 1;
        }
        
        categoryPrice[category] = price * multiply;
    }

    /**
    Withdraw the amount from the contract's balance. Only the contract owner can execute this function
    */
    function withdraw(uint256 amount) public onlyOwner {
        uint256 balance = address(this).balance;

        require(amount <= balance, "Requested to much");
        
        address payable _owner = address(uint160(owner()));
        
        _owner.transfer(amount);

        emit Withdrawal(amount);
    }
    
    function setBZNFeedContract(address new_bzn_feed) public onlyOwner {
        bznFeed = BZNFeed(new_bzn_feed);
    }

    function setEtherFeedContract(address new_eth_feed) public onlyOwner {
        ethFeed = ETHFeed(new_eth_feed);
    }
    
    //Buy many skinned or regular guns with BZN. This will reserve the amount of guns and allows the new_owner to invoke claimGuns for free
    function buyWithBZN(address referal, uint8 category, address payable new_owner, uint16 quanity) ensureShopOpen(category) payInBZN(referal, category, new_owner, quanity) public payable returns (bool) {
        factory.mintFor(new_owner, quanity, category);
            
        return true;
    }
    
    //Buy many skinned or regular guns with ETH. This will reserve the amount of guns and allows the new_owner to invoke claimGuns for free
    function buyWithEther(address referal, uint8 category, address new_owner, uint16 quanity) ensureShopOpen(category) payInETH(referal, category, new_owner, quanity) public payable returns (bool) {
        factory.mintFor(new_owner, quanity, category);
        
        return true;
    }
    
    function convert(uint256 usdValue, bool isBZN) public view returns (uint256) {
        if (isBZN) {
            return bznFeed.convert(usdValue);
        } else {
            uint256 priceForEtherInUsdWei = ethFeed.priceForEtherInUsdWei();
            
            return usdValue / (priceForEtherInUsdWei / 1e18);
        }
    }
    
    /**
    Get the price for skinned or regular guns in USD (wei)
    */
    function priceFor(uint8 category, uint16 quanity) public view returns (uint256, uint256) {
        require(quanity > 0);
        uint256 percent = categoryPercentIncrease[category];
        uint256 base = categoryPercentBase[category];

        uint256 currentPrice = categoryPrice[category];
        uint256 nextPrice = currentPrice;
        uint256 totalPrice = 0;
        //We can't use exponents because we'll overflow quickly
        //Only for loop :(
        for (uint i = 0; i < quanity; i++) {
            nextPrice = (currentPrice * percent) / base;
            
            currentPrice = nextPrice;
            
            totalPrice += nextPrice;
        }

        //Return the next price, as this is the true price
        return (nextPrice, totalPrice);
    }

    //Determine if a tokenId exists (has been sold)
    function sold(uint256 _tokenId) public view returns (bool) {
        return token.exists(_tokenId);
    }
    
    function receiveApproval(address from, uint256 tokenAmount, address tokenContract, bytes memory data) public payable returns (bool) {
        address referal;
        uint8 category;
        uint16 quanity;
        
        (referal, category, quanity) = abi.decode(data, (address, uint8, uint16));
        
        require(quanity >= 1);
        
        address payable _from = address(uint160(from)); 
        
        buyWithBZN(referal, category, _from, quanity);
        
        return true;
    }
}

contract GunFactory is Ownable {
    using strings for *;
    
    uint8 public constant PREMIUM_CATEGORY = 1;
    uint8 public constant MIDGRADE_CATEGORY = 2;
    uint8 public constant REGULAR_CATEGORY = 3;
    uint256 public constant ONE_MONTH = 2628000;
    
    uint256 public mintedGuns = 0;
    address preOrderAddress;
    IGunToken token;
    
    mapping(uint8 => uint256) internal gunsMintedByCategory;
    mapping(uint8 => uint256) internal totalGunsMintedByCategory;
    
    mapping(uint8 => uint256) internal firstMonthLimit;
    mapping(uint8 => uint256) internal secondMonthLimit;
    mapping(uint8 => uint256) internal thirdMonthLimit;
    
    uint256 internal startTime;
    mapping(uint8 => uint256) internal currentMonthEnd;
    uint256 internal monthOneEnd;
    uint256 internal monthTwoEnd;

    modifier onlyPreOrder {
        require(msg.sender == preOrderAddress, "Not authorized");
        _;
    }

    modifier isInitialized {
        require(preOrderAddress != address(0), "No linked preorder");
        require(address(token) != address(0), "No linked token");
        _;
    }
    
    constructor() public {
        firstMonthLimit[PREMIUM_CATEGORY] = 5000;
        firstMonthLimit[MIDGRADE_CATEGORY] = 20000;
        firstMonthLimit[REGULAR_CATEGORY] = 30000;
        
        secondMonthLimit[PREMIUM_CATEGORY] = 2500;
        secondMonthLimit[MIDGRADE_CATEGORY] = 10000;
        secondMonthLimit[REGULAR_CATEGORY] = 15000;
        
        thirdMonthLimit[PREMIUM_CATEGORY] = 600;
        thirdMonthLimit[MIDGRADE_CATEGORY] = 3000;
        thirdMonthLimit[REGULAR_CATEGORY] = 6000;
        
        startTime = block.timestamp;
        monthOneEnd = startTime + ONE_MONTH;
        monthTwoEnd = startTime + ONE_MONTH + ONE_MONTH;
        
        currentMonthEnd[PREMIUM_CATEGORY] = monthOneEnd;
        currentMonthEnd[MIDGRADE_CATEGORY] = monthOneEnd;
        currentMonthEnd[REGULAR_CATEGORY] = monthOneEnd;
    }

    function uintToString(uint v) internal pure returns (string memory) {
        if (v == 0) {
            return "0";
        }
        uint j = v;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (v != 0) {
            bstr[k--] = byte(uint8(48 + v % 10));
            v /= 10;
        }
        
        return string(bstr);
    }

    function mintFor(address newOwner, uint16 size, uint8 category) public onlyPreOrder isInitialized returns (uint256) {
        GunPreOrder preOrder = GunPreOrder(preOrderAddress);
        require(preOrder.categoryExists(category), "Invalid category");
        
        require(!hasReachedLimit(category), "The monthly limit has been reached");
        
        token.claimAllocation(newOwner, size, category);
        
        mintedGuns += size;
        
        gunsMintedByCategory[category] = gunsMintedByCategory[category] + size;
        totalGunsMintedByCategory[category] = totalGunsMintedByCategory[category] + size;
    }
    
    function hasReachedLimit(uint8 category) internal returns (bool) {
        uint256 currentTime = block.timestamp;
        uint256 limit = currentLimit(category);
        
        uint256 monthEnd = currentMonthEnd[category];
        
        //If the current block time is greater than or equal to the end of the month
        if (currentTime >= monthEnd) {
            //It's a new month, reset all limits
            //gunsMintedByCategory[PREMIUM_CATEGORY] = 0;
            //gunsMintedByCategory[MIDGRADE_CATEGORY] = 0;
            //gunsMintedByCategory[REGULAR_CATEGORY] = 0;
            gunsMintedByCategory[category] = 0;
            
            //Set next month end to be equal one month in advance
            //do this while the current time is greater than the next month end
            while (currentTime >= monthEnd) {
                monthEnd = monthEnd + ONE_MONTH;
            }
            
            //Finally, update the limit
            limit = currentLimit(category);
            currentMonthEnd[category] = monthEnd;
        }
        
        //Check if the limit has been reached
        return gunsMintedByCategory[category] >= limit;
    }
    
    function reachedLimit(uint8 category) public view returns (bool) {
        uint256 limit = currentLimit(category);
        
        return gunsMintedByCategory[category] >= limit;
    }
    
    function currentLimit(uint8 category) public view returns (uint256) {
        uint256 currentTime = block.timestamp;
        uint256 limit;
        if (currentTime < monthOneEnd) {
            limit = firstMonthLimit[category];
        } else if (currentTime < monthTwoEnd) {
            limit = secondMonthLimit[category];
        } else {
            limit = thirdMonthLimit[category];
        }
        
        return limit;
    }
    
    function setCategoryLimit(uint8 category, uint256 firstLimit, uint256 secondLimit, uint256 thirdLimit) public onlyOwner {
        require(firstMonthLimit[category] == 0);
        require(secondMonthLimit[category] == 0);
        require(thirdMonthLimit[category] == 0);
        
        firstMonthLimit[category] = firstLimit;
        secondMonthLimit[category] = secondLimit;
        thirdMonthLimit[category] = thirdLimit;
    }
    
    /**
    Attach the preOrder that will be receiving tokens being marked for sale by the
    sellCar function
    */
    function attachPreOrder(address dst) public onlyOwner {
        require(preOrderAddress == address(0));
        require(dst != address(0));

        //Enforce that address is indeed a preorder
        GunPreOrder preOrder = GunPreOrder(dst);

        preOrderAddress = address(preOrder);
    }

    /**
    Attach the token being used for things
    */
    function attachToken(address dst) public onlyOwner {
        require(address(token) == address(0));
        require(dst != address(0));

        //Enforce that address is indeed a preorder
        IGunToken ct = IGunToken(dst);

        token = ct;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"address","name":"tokenFactory","type":"address"},{"internalType":"address","name":"gp","type":"address"},{"internalType":"address","name":"ethfeed","type":"address"},{"internalType":"address","name":"bzn_address","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gunId","type":"uint256"},{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint8","name":"category","type":"uint8"}],"name":"GunsBought","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":"amount","type":"uint256"}],"name":"Withdrawal","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"category","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"quanity","type":"uint256"},{"indexed":false,"internalType":"address","name":"reserver","type":"address"}],"name":"consumerBulkBuy","type":"event"},{"constant":true,"inputs":[],"name":"COMMISSION_PERCENT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"allowCreateCategory","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"allowEthPayment","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"referal","type":"address"},{"internalType":"uint8","name":"category","type":"uint8"},{"internalType":"address payable","name":"new_owner","type":"address"},{"internalType":"uint16","name":"quanity","type":"uint16"}],"name":"buyWithBZN","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"referal","type":"address"},{"internalType":"uint8","name":"category","type":"uint8"},{"internalType":"address","name":"new_owner","type":"address"},{"internalType":"uint16","name":"quanity","type":"uint16"}],"name":"buyWithEther","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"bznFeed","outputs":[{"internalType":"contract BZNFeed","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"categoryExists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"categoryKilled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"categoryOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"categoryPercentBase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"categoryPercentIncrease","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"categoryPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint8","name":"","type":"uint8"},{"internalType":"address","name":"","type":"address"}],"name":"categoryReserveAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"usdValue","type":"uint256"},{"internalType":"bool","name":"isBZN","type":"bool"}],"name":"convert","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint8","name":"category","type":"uint8"}],"name":"createCategory","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"disableCreateCategories","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"ethFeed","outputs":[{"internalType":"contract ETHFeed","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint8","name":"category","type":"uint8"}],"name":"killCategory","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint8","name":"category","type":"uint8"},{"internalType":"uint16","name":"quanity","type":"uint16"}],"name":"priceFor","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"internalType":"address","name":"tokenContract","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"receiveApproval","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"requiredEtherPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"requiredEtherPercentBase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"new_bzn_feed","type":"address"}],"name":"setBZNFeedContract","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"referral","type":"address"},{"internalType":"uint256","name":"percent","type":"uint256"}],"name":"setCommission","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"new_eth_feed","type":"address"}],"name":"setEtherFeedContract","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"percent","type":"uint256"},{"internalType":"uint256","name":"base","type":"uint256"},{"internalType":"uint8","name":"category","type":"uint8"}],"name":"setEtherPercent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"increase","type":"uint256"},{"internalType":"uint256","name":"base","type":"uint256"},{"internalType":"uint8","name":"category","type":"uint8"}],"name":"setPercentIncrease","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint8","name":"category","type":"uint8"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"bool","name":"inWei","type":"bool"}],"name":"setPrice","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint8","name":"category","type":"uint8"},{"internalType":"bool","name":"open","type":"bool"}],"name":"setShopState","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"sold","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"bool","name":"enable","type":"bool"}],"name":"toggleETHPayment","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"internalType":"contract IGunToken","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

6080604052600b805461ff001960ff199091166001171661010017905534801561002857600080fd5b50604051612452380380612452833981810160405260a081101561004b57600080fd5b50805160208201516040830151606084015160809094015192939192909190600061007d6001600160e01b0361025616565b600080546001600160a01b0319166001600160a01b0383169081178255604051929350917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a350600b80546001600160a01b03968716620100000262010000600160b01b0319909116179055600c80549486166001600160a01b0319958616179055600e805492861692851692909217909155600d805491851691841691909117905560108054919093169116179055620186c37f3e5fec24aa4dc4e5aee2e025e51e1392c72a2500577559fae9665c6d52bd6a3155620186a07fb39221ace053465ec3453ce2b36430bd138b997ecea25c1043da0c366812b828819055620186b97f8819ef417987f8ae7a81f42cdfb18815282fe989326fbff903d13cf0e03ace29557fb7c774451310d1be4108bc180d1b52823cb0ee0274a6c0081bcaf94f115fb96d819055620186af7f75f96ab15d697e93042dc45b5c896c4b27e89bb6eaf39475c5c371cb2513f7d2557f3be6fd20d5acfde5b873b48692cd31f4d3c7e8ee8a813af4696af8859e5ca6c655735b3256965e7c3cf26e11fcaf296dfc8807c010736000526004602052600a7ff7029b8380c1de16df5eabe7fe390ffd22d7c52023371907818edf13e040ff4f5561025a565b3390565b6121e9806102696000396000f3fe6080604052600436106102195760003560e01c80638f4ffcb111610123578063c768ad1a116100ab578063e95087931161006f578063e95087931461085f578063ea72e184146108a1578063f2fde38b146108d4578063f8160b5014610907578063fc0c546a1461091c57610219565b8063c768ad1a1461075b578063c8e5ae4c1461079d578063ccba0932146107d2578063d5deb15b146107ff578063e5174e081461082c57610219565b8063a68b8552116100f2578063a68b855214610678578063aa30b420146106a5578063b404e001146106e0578063b51bcc0e146106f5578063bea82b061461072257610219565b80638f4ffcb11461052b5780639a5ef369146105f05780639c03facb146106225780639f57769e1461064c57610219565b80633d176045116101a6578063715018a611610175578063715018a61461046f57806373c81a8b14610484578063762c8d1f146104b15780638da5cb5b146105015780638f32d59b1461051657610219565b80633d176045146103cf578063512ceb3d146103fc5780635e19d05c14610429578063690d5ff41461045a57610219565b806323539a84116101ed57806323539a84146102ca57806324b5b280146103065780632e07a5be146103335780632e1a7d4d1461036c57806331729a451461039657610219565b80627a77761461021e57806301b49e821461025d57806305bfa9eb1461027457806321bf73841461029d575b600080fd5b34801561022a57600080fd5b5061024b6004803603602081101561024157600080fd5b503560ff16610931565b60408051918252519081900360200190f35b34801561026957600080fd5b50610272610943565b005b34801561028057600080fd5b50610289610996565b604080519115158252519081900360200190f35b3480156102a957600080fd5b50610272600480360360208110156102c057600080fd5b503560ff166109a4565b3480156102d657600080fd5b5061024b600480360360408110156102ed57600080fd5b50803560ff1690602001356001600160a01b0316610a3d565b34801561031257600080fd5b506102896004803603602081101561032957600080fd5b503560ff16610a5a565b34801561033f57600080fd5b506102726004803603606081101561035657600080fd5b508035906020810135906040013560ff16610a6f565b34801561037857600080fd5b506102726004803603602081101561038f57600080fd5b5035610ae5565b3480156103a257600080fd5b50610272600480360360408110156103b957600080fd5b506001600160a01b038135169060200135610bf2565b3480156103db57600080fd5b5061024b600480360360208110156103f257600080fd5b503560ff16610c76565b34801561040857600080fd5b5061024b6004803603602081101561041f57600080fd5b503560ff16610c88565b34801561043557600080fd5b5061043e610c9a565b604080516001600160a01b039092168252519081900360200190f35b34801561046657600080fd5b5061043e610ca9565b34801561047b57600080fd5b50610272610cb8565b34801561049057600080fd5b50610272600480360360208110156104a757600080fd5b503560ff16610d49565b3480156104bd57600080fd5b506104e8600480360360408110156104d457600080fd5b50803560ff16906020013561ffff16610dc0565b6040805192835260208301919091528051918290030190f35b34801561050d57600080fd5b5061043e610e39565b34801561052257600080fd5b50610289610e48565b6102896004803603608081101561054157600080fd5b6001600160a01b03823581169260208101359260408201359092169181019060808101606082013564010000000081111561057b57600080fd5b82018360208201111561058d57600080fd5b803590602001918460018302840111640100000000831117156105af57600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250929550610e6c945050505050565b3480156105fc57600080fd5b5061024b6004803603604081101561061357600080fd5b50803590602001351515610ecc565b34801561062e57600080fd5b506102896004803603602081101561064557600080fd5b5035610fe4565b34801561065857600080fd5b506102726004803603602081101561066f57600080fd5b50351515611068565b34801561068457600080fd5b506102896004803603602081101561069b57600080fd5b503560ff166110c9565b3480156106b157600080fd5b50610272600480360360608110156106c857600080fd5b5060ff813516906020810135906040013515156110de565b3480156106ec57600080fd5b5061024b611154565b34801561070157600080fd5b506102896004803603602081101561071857600080fd5b503560ff16611159565b34801561072e57600080fd5b506102726004803603606081101561074557600080fd5b508035906020810135906040013560ff1661116e565b6102896004803603608081101561077157600080fd5b5080356001600160a01b0390811691602081013560ff1691604082013516906060013561ffff166111d8565b3480156107a957600080fd5b50610272600480360360408110156107c057600080fd5b5060ff813516906020013515156119c9565b3480156107de57600080fd5b5061024b600480360360208110156107f557600080fd5b503560ff16611a9e565b34801561080b57600080fd5b5061024b6004803603602081101561082257600080fd5b503560ff16611ab0565b34801561083857600080fd5b506102726004803603602081101561084f57600080fd5b50356001600160a01b0316611ac2565b6102896004803603608081101561087557600080fd5b5080356001600160a01b0390811691602081013560ff1691604082013516906060013561ffff16611b2b565b3480156108ad57600080fd5b50610272600480360360208110156108c457600080fd5b50356001600160a01b0316611f7e565b3480156108e057600080fd5b50610272600480360360208110156108f757600080fd5b50356001600160a01b0316611fe7565b34801561091357600080fd5b5061028961203a565b34801561092857600080fd5b5061043e612043565b600a6020526000908152604090205481565b61094b610e48565b61098a576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b600b805460ff19169055565b600b54610100900460ff1681565b6109ac610e48565b6109eb576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b60ff8082166000908152600360205260409020541615610a0a57600080fd5b60ff166000908152600260209081526040808320805460ff19908116909155600390925290912080549091166001179055565b600560209081526000928352604080842090915290825290205481565b60026020526000908152604090205460ff1681565b610a77610e48565b610ab6576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b818311610ac257600080fd5b60ff16600090815260066020908152604080832094909455600790529190912055565b610aed610e48565b610b2c576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b4780821115610b76576040805162461bcd60e51b81526020600482015260116024820152700a4cae2eacae6e8cac840e8de40daeac6d607b1b604482015290519081900360640190fd5b6000610b80610e39565b6040519091506001600160a01b0382169084156108fc029085906000818181858888f19350505050158015610bb9573d6000803e3d6000fd5b506040805184815290517f4e70a604b23a8edee2b1d0a656e9b9c00b73ad8bb1afc2c59381ee9f69197de79181900360200190a1505050565b610bfa610e48565b610c39576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b60058111610c4657600080fd5b605f8110610c5357600080fd5b6001600160a01b0390911660009081526004602052604090206004199091019055565b60076020526000908152604090205481565b60066020526000908152604090205481565b600e546001600160a01b031681565b600f546001600160a01b031681565b610cc0610e48565b610cff576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b600080546040516001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080546001600160a01b0319169055565b610d51610e48565b610d90576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b600b5460ff16610d9f57600080fd5b60ff166000908152600160208190526040909120805460ff19169091179055565b60008060008361ffff1611610dd457600080fd5b60ff8416600090815260066020908152604080832054600783528184205460089093529083205490928190805b8861ffff16811015610e2a578486850281610e1857fe5b04935083925090820190600101610e01565b50909890975095505050505050565b6000546001600160a01b031690565b600080546001600160a01b0316610e5d612058565b6001600160a01b031614905090565b600080600080848060200190516060811015610e8757600080fd5b50805160208201516040909201519094509092509050600161ffff82161015610eaf57600080fd5b87610ebc848483856111d8565b5060019998505050505050505050565b60008115610f5357600f546040805163a3908e1b60e01b81526004810186905290516001600160a01b039092169163a3908e1b91602480820192602092909190829003018186803b158015610f2057600080fd5b505afa158015610f34573d6000803e3d6000fd5b505050506040513d6020811015610f4a57600080fd5b50519050610fde565b600e546040805163b04ee50960e01b815290516000926001600160a01b03169163b04ee509916004808301926020929190829003018186803b158015610f9857600080fd5b505afa158015610fac573d6000803e3d6000fd5b505050506040513d6020811015610fc257600080fd5b50519050670de0b6b3a764000081048481610fd957fe5b049150505b92915050565b600b5460408051634f558e7960e01b81526004810184905290516000926201000090046001600160a01b031691634f558e79916024808301926020929190829003018186803b15801561103657600080fd5b505afa15801561104a573d6000803e3d6000fd5b505050506040513d602081101561106057600080fd5b505192915050565b611070610e48565b6110af576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b600b80549115156101000261ff0019909216919091179055565b60036020526000908152604090205460ff1681565b6110e6610e48565b611125576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b670de0b6b3a76400008115611138575060015b60ff909316600090815260086020526040902091909202905550565b600581565b60016020526000908152604090205460ff1681565b611176610e48565b6111b5576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b60ff16600090815260096020908152604080832094909455600a90529190912055565b60ff808416600090815260016020526040812054909185911661123c576040805162461bcd60e51b815260206004820152601760248201527643617465676f727920646f65736e27742065786973742160481b604482015290519081900360640190fd5b60ff8082166000908152600260205260409020541661129a576040805162461bcd60e51b815260206004820152601560248201527443617465676f7279206973206e6f74206f70656e2160581b604482015290519081900360640190fd5b60408051600480825260a082019092528791879187918791606091602082016080803883390190505090506112cf8483610dc0565b826000815181106112dc57fe5b60200260200101836003815181106112f057fe5b602002602001018281525082815250505060008160008151811061131057fe5b60200260200101511161135e576040805162461bcd60e51b8152602060048201526011602482015270141c9a58d9481b9bdd081e595d081cd95d607a1b604482015290519081900360640190fd5b8060008151811061136b57fe5b6020026020010151600860008660ff1660ff168152602001908152602001600020819055506113af816003815181106113a057fe5b60200260200101516001610ecc565b816001815181106113bc57fe5b60209081029190910101526001600160a01b03851615611430576001600160a01b0385166000908152600460205260409020548151606491600501908390600190811061140557fe5b6020026020010151028161141557fe5b048160028151811061142357fe5b6020026020010181815250505b60ff84166000908152600a602090815260408083205460099092528220548351611470908590600390811061146157fe5b60200260200101516000610ecc565b028161147857fe5b049050803410156114ba5760405162461bcd60e51b81526004018080602001828103825260248152602001806121466024913960400191505060405180910390fd5b600d5482516001600160a01b03909116906379cc6790908690606490869060029081106114e357fe5b6020026020010151866001815181106114f857fe5b602002602001015103601e028161150b57fe5b046040518363ffffffff1660e01b815260040180836001600160a01b03166001600160a01b0316815260200182815260200192505050600060405180830381600087803b15801561155b57600080fd5b505af115801561156f573d6000803e3d6000fd5b5050600d5460105485516001600160a01b0392831694506323b872dd9350889290911690606490879060029081106115a357fe5b6020026020010151876001815181106115b857fe5b602002602001015103601e02816115cb57fe5b04866002815181106115d957fe5b6020026020010151876001815181106115ee57fe5b602002602001015103036040518463ffffffff1660e01b815260040180846001600160a01b03166001600160a01b03168152602001836001600160a01b03166001600160a01b031681526020018281526020019350505050602060405180830381600087803b15801561166057600080fd5b505af1158015611674573d6000803e3d6000fd5b505050506040513d602081101561168a57600080fd5b5050600c54604080516336896c7f60e01b81526001600160a01b038d8116600483015261ffff8d16602483015260ff8f166044830152915191909216916336896c7f9160648083019260209291908290030181600087803b1580156116ee57600080fd5b505af1158015611702573d6000803e3d6000fd5b505050506040513d602081101561171857600080fd5b50600198505080341115611760576040516001600160a01b038516903483900380156108fc02916000818181858888f1935050505015801561175e573d6000803e3d6000fd5b505b6001600160a01b038616156119ba576001600160a01b0386163314156117cd576040805162461bcd60e51b815260206004820181905260248201527f546865207265666572616c2063616e6e6f74206265207468652073656e646572604482015290519081900360640190fd5b6001600160a01b0386163214156118155760405162461bcd60e51b815260040180806020018281038252602b81526020018061216a602b913960400191505060405180910390fd5b836001600160a01b0316866001600160a01b031614156118665760405162461bcd60e51b81526004018080602001828103825260238152602001806120fd6023913960400191505060405180910390fd5b600d5482516001600160a01b03909116906323b872dd90869089908690600290811061188e57fe5b60200260200101516040518463ffffffff1660e01b815260040180846001600160a01b03166001600160a01b03168152602001836001600160a01b03166001600160a01b031681526020018281526020019350505050602060405180830381600087803b1580156118fe57600080fd5b505af1158015611912573d6000803e3d6000fd5b505050506040513d602081101561192857600080fd5b50506001600160a01b0386166000908152600460205260409020546064906005018202048260028151811061195957fe5b6020026020010181815250506000869050806001600160a01b03166108fc8460028151811061198457fe5b60200260200101519081150290604051600060405180830381858888f193505050501580156119b7573d6000803e3d6000fd5b50505b50505050505050949350505050565b6119d1610e48565b611a10576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b8160ff1660011480611a2557508160ff166002145b80611a3357508160ff166003145b611a3c57600080fd5b60ff8083166000908152600360205260409020541615611a5b57600080fd5b60ff80831660009081526001602052604090205416611a7957600080fd5b60ff919091166000908152600260205260409020805460ff1916911515919091179055565b60086020526000908152604090205481565b60096020526000908152604090205481565b611aca610e48565b611b09576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b600f80546001600160a01b0319166001600160a01b0392909216919091179055565b60ff8084166000908152600160205260408120549091859116611b8f576040805162461bcd60e51b815260206004820152601760248201527643617465676f727920646f65736e27742065786973742160481b604482015290519081900360640190fd5b60ff80821660009081526002602052604090205416611bed576040805162461bcd60e51b815260206004820152601560248201527443617465676f7279206973206e6f74206f70656e2160581b604482015290519081900360640190fd5b85858585600b60019054906101000a900460ff16611c52576040805162461bcd60e51b815260206004820152601960248201527f455448205061796d656e7473206172652064697361626c656400000000000000604482015290519081900360640190fd5b600080611c5f8584610dc0565b909250905081611caa576040805162461bcd60e51b8152602060048201526011602482015270141c9a58d9481b9bdd081e595d081cd95d607a1b604482015290519081900360640190fd5b60ff85166000908152600860205260408120839055611cc98282610ecc565b905080341015611d19576040805162461bcd60e51b81526020600482015260166024820152754e6f7420656e6f7567682045746865722073656e742160501b604482015290519081900360640190fd5b600c60009054906101000a90046001600160a01b03166001600160a01b03166336896c7f8c8c8f6040518463ffffffff1660e01b815260040180846001600160a01b03166001600160a01b031681526020018361ffff1661ffff1681526020018260ff1660ff1681526020019350505050602060405180830381600087803b158015611da457600080fd5b505af1158015611db8573d6000803e3d6000fd5b505050506040513d6020811015611dce57600080fd5b50600199505080341115611e11576040513482900390339082156108fc029083906000818181858888f19350505050158015611e0e573d6000803e3d6000fd5b50505b6001600160a01b03871615611f6e576001600160a01b038716331415611e7e576040805162461bcd60e51b815260206004820181905260248201527f546865207265666572616c2063616e6e6f74206265207468652073656e646572604482015290519081900360640190fd5b6001600160a01b038716321415611ec65760405162461bcd60e51b815260040180806020018281038252602b81526020018061216a602b913960400191505060405180910390fd5b846001600160a01b0316876001600160a01b03161415611f175760405162461bcd60e51b81526004018080602001828103825260238152602001806120fd6023913960400191505060405180910390fd5b6001600160a01b038716600081815260046020526040808220549051600590910192606485850204928b926108fc85150291859190818181858888f19350505050158015611f69573d6000803e3d6000fd5b505050505b5050505050505050949350505050565b611f86610e48565b611fc5576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b600e80546001600160a01b0319166001600160a01b0392909216919091179055565b611fef610e48565b61202e576040805162461bcd60e51b81526020600482018190526024820152600080516020612195833981519152604482015290519081900360640190fd5b6120378161205c565b50565b600b5460ff1681565b600b546201000090046001600160a01b031681565b3390565b6001600160a01b0381166120a15760405162461bcd60e51b81526004018080602001828103825260268152602001806121206026913960400191505060405180910390fd5b600080546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0319166001600160a01b039290921691909117905556fe546865207265666572616c2063616e6e6f7420626520746865206e6577206f776e65724f776e61626c653a206e6577206f776e657220697320746865207a65726f2061646472657373427579696e67207769746820425a4e20726571756972657320736f6d6520457468657221546865207265666572616c2063616e6e6f7420626520746865207472616e616374696f6e206f726967696e4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572a265627a7a72315820d825db356607779dcbb56ceb6bcafae812457e25afb6d01fa2f3d4cd7537963064736f6c634300051100320000000000000000000000002d6e10561b320c4f31a903bf0fa92a1ed58637c0000000000000000000000000fac59958237ae5a5aa5075f944435899b877792200000000000000000000000083f11770176d959b19f9cc6e2d5a051cb101bdaf000000000000000000000000edb41d07306a43519045a2f5ac336a9bab7036a00000000000000000000000006524b87960c2d573ae514fd4181777e7842435d4

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

0000000000000000000000002d6e10561b320c4f31a903bf0fa92a1ed58637c0000000000000000000000000FAC59958237AE5A5aa5075f944435899B877792200000000000000000000000083f11770176d959B19F9cC6E2d5a051cb101bdAf000000000000000000000000eDb41D07306A43519045A2F5ac336a9bAB7036A00000000000000000000000006524B87960c2d573AE514fd4181777E7842435d4

-----Decoded View---------------
Arg [0] : tokenAddress (address): 0x2D6e10561B320C4F31a903bF0FA92a1Ed58637C0
Arg [1] : tokenFactory (address): 0xFAC59958237AE5A5aa5075f944435899B8777922
Arg [2] : gp (address): 0x83f11770176d959B19F9cC6E2d5a051cb101bdAf
Arg [3] : ethfeed (address): 0xeDb41D07306A43519045A2F5ac336a9bAB7036A0
Arg [4] : bzn_address (address): 0x6524B87960c2d573AE514fd4181777E7842435d4

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000002d6e10561b320c4f31a903bf0fa92a1ed58637c0
Arg [1] : 000000000000000000000000FAC59958237AE5A5aa5075f944435899B8777922
Arg [2] : 00000000000000000000000083f11770176d959B19F9cC6E2d5a051cb101bdAf
Arg [3] : 000000000000000000000000eDb41D07306A43519045A2F5ac336a9bAB7036A0
Arg [4] : 0000000000000000000000006524B87960c2d573AE514fd4181777E7842435d4

66954:12237:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68554:57;;8:9:-1;5:2;;;30:1;27;20:12;5:2;68554:57:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;68554:57:0;;;;:::i;:::-;;;;;;;;;;;;;;;;73710:98;;8:9:-1;5:2;;;30:1;27;20:12;5:2;73710:98:0;;;:::i;:::-;;68663:34;;8:9:-1;5:2;;;30:1;27;20:12;5:2;68663:34:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;74794:201;;8:9:-1;5:2;;;30:1;27;20:12;5:2;74794:201:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;74794:201:0;;;;:::i;67944:74::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;67944:74:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;67944:74:0;;;;;;;;-1:-1:-1;;;;;67944:74:0;;:::i;67616:42::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;67616:42:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;67616:42:0;;;;:::i;74322:248::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;74322:248:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;74322:248:0;;;;;;;;;;;;;;:::i;75785:320::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;75785:320:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;75785:320:0;;:::i;73980:267::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;73980:267:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;73980:267:0;;;;;;;;:::i;68274:52::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;68274:52:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;68274:52:0;;;;:::i;68211:56::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;68211:56:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;68211:56:0;;;;:::i;68924:22::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;68924:22:0;;;:::i;:::-;;;;-1:-1:-1;;;;;68924:22:0;;;;;;;;;;;;;;68953;;8:9:-1;5:2;;;30:1;27;20:12;5:2;68953:22:0;;;:::i;51422:140::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51422:140:0;;;:::i;73542:156::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;73542:156:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;73542:156:0;;;;:::i;77694:796::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;77694:796:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;77694:796:0;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;50611:79;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50611:79:0;;;:::i;50977:94::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50977:94:0;;;:::i;78670:518::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;78670:518:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;78670:518:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;78670:518:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;78670:518:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;78670:518:0;;-1:-1:-1;78670:518:0;;-1:-1:-1;;;;;78670:518:0:i;77267:338::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;77267:338:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;77267:338:0;;;;;;;;;:::i;78551:107::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;78551:107:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;78551:107:0;;:::i;73816:99::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;73816:99:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;73816:99:0;;;;:::i;67665:44::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;67665:44:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;67665:44:0;;;;:::i;75413:243::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;75413:243:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;75413:243:0;;;;;;;;;;;;;;;;:::i;67474:46::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;67474:46:0;;;:::i;67565:44::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;67565:44:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;67565:44:0;;;;:::i;74582:200::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;74582:200:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;74582:200:0;;;;;;;;;;;;;;:::i;76514:299::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;76514:299:0;;-1:-1:-1;;;;;76514:299:0;;;;;;;;;;;;;;;;;;;;;;;:::i;75054:280::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;75054:280:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;75054:280:0;;;;;;;;;;;:::i;68380:46::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;68380:46:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;68380:46:0;;;;:::i;68494:53::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;68494:53:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;68494:53:0;;;;:::i;76117:117::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;76117:117:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;76117:117:0;-1:-1:-1;;;;;76117:117:0;;:::i;76966:289::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;76966:289:0;;-1:-1:-1;;;;;76966:289:0;;;;;;;;;;;;;;;;;;;;;;;:::i;76242:119::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;76242:119:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;76242:119:0;-1:-1:-1;;;;;76242:119:0;;:::i;51717:109::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51717:109:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51717:109:0;-1:-1:-1;;;;;51717:109:0;;:::i;68618:38::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;68618:38:0;;;:::i;68736:22::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;68736:22:0;;;:::i;68554:57::-;;;;;;;;;;;;;:::o;73710:98::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;73773:19;:27;;-1:-1:-1;;73773:27:0;;;73710:98::o;68663:34::-;;;;;;;;;:::o;74794:201::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;74869:24;;;;;;;;:14;:24;;;;;;;74868:25;74860:34;;;;;;74915:22;;74940:5;74915:22;;;:12;:22;;;;;;;;:30;;-1:-1:-1;;74915:30:0;;;;;;74956:14;:24;;;;;;:31;;;;;74915:30;74956:31;;;74794:201::o;67944:74::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;67616:42::-;;;;;;;;;;;;;;;:::o;74322:248::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;74445:4;74434:8;:15;74426:24;;;;;;74471:33;;;;;;:23;:33;;;;;;;;:44;;;;74526:19;:29;;;;;;:36;74322:248::o;75785:320::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;75865:21;75907:17;;;;75899:47;;;;;-1:-1:-1;;;75899:47:0;;;;;;;;;;;;-1:-1:-1;;;75899:47:0;;;;;;;;;;;;;;;75967:22;76008:7;:5;:7::i;:::-;76038:23;;75967:50;;-1:-1:-1;;;;;;76038:15:0;;;:23;;;;;76054:6;;76038:23;;;;76054:6;76038:15;:23;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;76079:18:0;;;;;;;;;;;;;;;;;50880:1;;75785:320;:::o;73980:267::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;67519:1;74074:7;:28;74066:37;;;;;;74132:2;74122:7;:12;74114:21;;;;;;-1:-1:-1;;;;;74205:24:0;;;;;;;:14;:24;;;;;-1:-1:-1;;74156:28:0;;;74205:34;;73980:267::o;68274:52::-;;;;;;;;;;;;;:::o;68211:56::-;;;;;;;;;;;;;:::o;68924:22::-;;;-1:-1:-1;;;;;68924:22:0;;:::o;68953:::-;;;-1:-1:-1;;;;;68953:22:0;;:::o;51422:140::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;51521:1;51505:6;;51484:40;;-1:-1:-1;;;;;51505:6:0;;;;51484:40;;51521:1;;51484:40;51552:1;51535:19;;-1:-1:-1;;;;;;51535:19:0;;;51422:140::o;73542:156::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;73618:19;;;;73610:28;;;;;;73659:24;;;;;;73686:4;73659:24;;;;;;;;:31;;-1:-1:-1;;73659:31:0;;;;;;73542:156::o;77694:796::-;77765:7;77774;77812:1;77802:7;:11;;;77794:20;;;;;;77843:33;;;77825:15;77843:33;;;:23;:33;;;;;;;;;77902:19;:29;;;;;;77967:13;:23;;;;;;;77843:33;;77967:23;;77825:15;78170:210;78191:7;78187:11;;:1;:11;78170:210;;;78259:4;78248:7;78233:12;:22;78232:31;;;;;;;-1:-1:-1;78232:31:0;;-1:-1:-1;78345:23:0;;;;78200:3;;78170:210;;;-1:-1:-1;78460:9:0;;;;-1:-1:-1;77694:796:0;-1:-1:-1;;;;;;77694:796:0:o;50611:79::-;50649:7;50676:6;-1:-1:-1;;;;;50676:6:0;50611:79;:::o;50977:94::-;51017:4;51057:6;;-1:-1:-1;;;;;51057:6:0;51041:12;:10;:12::i;:::-;-1:-1:-1;;;;;51041:22:0;;51034:29;;50977:94;:::o;78670:518::-;78796:4;78813:15;78839:14;78864;78941:4;78930:42;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;78930:42:0;;;;;;;;;;;;;-1:-1:-1;78930:42:0;;-1:-1:-1;78930:42:0;-1:-1:-1;79012:1:0;79001:12;;;;;78993:21;;;;;;79075:4;79103:45;79114:7;79123:8;79075:4;79140:7;79103:10;:45::i;:::-;-1:-1:-1;79176:4:0;;78670:518;-1:-1:-1;;;;;;;;;78670:518:0:o;77267:338::-;77335:7;77359:5;77355:243;;;77388:7;;:25;;;-1:-1:-1;;;77388:25:0;;;;;;;;;;-1:-1:-1;;;;;77388:7:0;;;;:15;;:25;;;;;;;;;;;;;;;:7;:25;;;5:2:-1;;;;30:1;27;20:12;5:2;77388:25:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;77388:25:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;77388:25:0;;-1:-1:-1;77381:32:0;;77355:243;77478:7;;:31;;;-1:-1:-1;;;77478:31:0;;;;77446:29;;-1:-1:-1;;;;;77478:7:0;;:29;;:31;;;;;;;;;;;;;;:7;:31;;;5:2:-1;;;;30:1;27;20:12;5:2;77478:31:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;77478:31:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;77478:31:0;;-1:-1:-1;77581:4:0;77478:31;77557:28;77545:8;:41;;;;;;77538:48;;;77355:243;77267:338;;;;:::o;78551:107::-;78628:5;;:22;;;-1:-1:-1;;;78628:22:0;;;;;;;;;;-1:-1:-1;;78628:5:0;;;-1:-1:-1;;;;;78628:5:0;;:12;;:22;;;;;;;;;;;;;;:5;:22;;;5:2:-1;;;;30:1;27;20:12;5:2;78628:22:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;78628:22:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;78628:22:0;;78551:107;-1:-1:-1;;78551:107:0:o;73816:99::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;73883:15;:24;;;;;;;-1:-1:-1;;73883:24:0;;;;;;;;;73816:99::o;67665:44::-;;;;;;;;;;;;;;;:::o;75413:243::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;75521:4;75536:50;;;;-1:-1:-1;75573:1:0;75536:50;75606:23;;;;;;;;:13;:23;;;;;75632:16;;;;75606:42;;-1:-1:-1;75413:243:0:o;67474:46::-;67519:1;67474:46;:::o;67565:44::-;;;;;;;;;;;;;;;:::o;74582:200::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;74682:30;;;;;;:20;:30;;;;;;;;:40;;;;74733:24;:34;;;;;;:41;74582:200::o;76514:299::-;69160:24;;;;76707:4;69160:24;;;:14;:24;;;;;;76707:4;;76625:8;;69160:24;69152:60;;;;;-1:-1:-1;;;69152:60:0;;;;;;;;;;;;-1:-1:-1;;;69152:60:0;;;;;;;;;;;;;;;69231:22;;;;;;;;:12;:22;;;;;;;69223:56;;;;;-1:-1:-1;;;69223:56:0;;;;;;;;;;;;-1:-1:-1;;;69223:56:0;;;;;;;;;;;;;;;70944:16;;;70958:1;70944:16;;;;;;;;;76644:7;;76653:8;;76663:9;;76674:7;;70918:23;;70944:16;;;17:15:-1;;105:10;70944:16:0;88:34:-1;136:17;;-1:-1;70944:16:0;70918:42;;71078:27;71087:8;71097:7;71078:8;:27::i;:::-;71054:6;71061:1;71054:9;;;;;;;;;;;;;71065:6;71072:1;71065:9;;;;;;;;;;;;;71053:52;;;;;;;;;;71136:1;71124:6;71131:1;71124:9;;;;;;;;;;;;;;:13;71116:43;;;;;-1:-1:-1;;;71116:43:0;;;;;;;;;;;;-1:-1:-1;;;71116:43:0;;;;;;;;;;;;;;;71210:6;71217:1;71210:9;;;;;;;;;;;;;;71184:13;:23;71198:8;71184:23;;;;;;;;;;;;;;;:35;;;;71252:24;71260:6;71267:1;71260:9;;;;;;;;;;;;;;71271:4;71252:7;:24::i;:::-;71240:6;71247:1;71240:9;;;;;;;;;;;;;;;;;:36;-1:-1:-1;;;;;71416:21:0;;;71412:132;;-1:-1:-1;;;;;71501:23:0;;;;;;:14;:23;;;;;;71467:9;;71529:3;;67519:1;71480:44;;71467:6;;71474:1;;71467:9;;;;;;;;;;;;:58;71466:66;;;;;;71454:6;71461:1;71454:9;;;;;;;;;;;;;:78;;;;;71412:132;71651:34;;;71564:21;71651:34;;;:24;:34;;;;;;;;;71617:20;:30;;;;;;71597:9;;71589:25;;71597:6;;71604:1;;71597:9;;;;;;;;;;;;71608:5;71589:7;:25::i;:::-;:58;71588:97;;;;;;71564:121;;71727:13;71714:9;:26;;71706:75;;;;-1:-1:-1;;;71706:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71802:3;;71841:9;;-1:-1:-1;;;;;71802:3:0;;;;:12;;71815:9;;71860:3;;71841:6;;71848:1;;71841:9;;;;;;;;;;;;71829:6;71836:1;71829:9;;;;;;;;;;;;;;:21;71854:2;71828:28;71827:36;;;;;;71802:63;;;;;;;;;;;;;-1:-1:-1;;;;;71802:63:0;-1:-1:-1;;;;;71802:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;71802:63:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;71876:3:0;;71904:8;;71953:9;;-1:-1:-1;;;;;71876:3:0;;;;-1:-1:-1;71876:16:0;;-1:-1:-1;71893:9:0;;71904:8;;;;71972:3;;71953:9;;71960:1;;71953:9;;;;;;;;;;;;71941:6;71948:1;71941:9;;;;;;;;;;;;;;:21;71966:2;71940:28;71939:36;;;;;;71926:6;71933:1;71926:9;;;;;;;;;;;;;;71914:6;71921:1;71914:9;;;;;;;;;;;;;;:21;:62;71876:101;;;;;;;;;;;;;-1:-1:-1;;;;;71876:101:0;-1:-1:-1;;;;;71876:101:0;;;;;;-1:-1:-1;;;;;71876:101:0;-1:-1:-1;;;;;71876:101:0;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;71876:101:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;71876:101:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;76724:7:0;;:45;;;-1:-1:-1;;;76724:45:0;;-1:-1:-1;;;;;76724:45:0;;;;;;;;;;;;;;;;;;;;;;;:7;;;;;:15;;:45;;;;;71876:101;;76724:45;;;;;;;:7;;:45;;;5:2:-1;;;;30:1;27;20:12;5:2;76724:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;76724:45:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;76801:4:0;;-1:-1:-1;;72036:13:0;72024:9;:25;72020:103;;;72066:45;;-1:-1:-1;;;;;72066:18:0;;;72085:9;:25;;;72066:45;;;;;;;;;72085:25;72066:18;:45;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;72066:45:0;72020:103;-1:-1:-1;;;;;72147:21:0;;;72143:607;;-1:-1:-1;;;;;72193:21:0;;72204:10;72193:21;;72185:66;;;;;-1:-1:-1;;;72185:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;72274:20:0;;72285:9;72274:20;;72266:76;;;;-1:-1:-1;;;72266:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72376:9;-1:-1:-1;;;;;72365:20:0;:7;-1:-1:-1;;;;;72365:20:0;;;72357:68;;;;-1:-1:-1;;;72357:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72454:3;;72491:9;;-1:-1:-1;;;;;72454:3:0;;;;:16;;72471:9;;72482:7;;72491:6;;72498:1;;72491:9;;;;;;;;;;;;72454:47;;;;;;;;;;;;;-1:-1:-1;;;;;72454:47:0;-1:-1:-1;;;;;72454:47:0;;;;;;-1:-1:-1;;;;;72454:47:0;-1:-1:-1;;;;;72454:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;72454:47:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;72454:47:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;;72581:23:0;;;;;;:14;72454:47;72581:23;;;;;72609:3;;67519:1;72560:44;72543:62;;72542:70;72530:6;72537:1;72530:9;;;;;;;;;;;;;:82;;;;;72641:24;72684:7;72641:52;;72710:8;-1:-1:-1;;;;;72710:17:0;:28;72728:6;72735:1;72728:9;;;;;;;;;;;;;;72710:28;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;72710:28:0;72143:607;;69290:1;;;;;;76514:299;;;;;;;:::o;75054:280::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;75139:8;:13;;75151:1;75139:13;:30;;;;75156:8;:13;;75168:1;75156:13;75139:30;:47;;;;75173:8;:13;;75185:1;75173:13;75139:47;75131:56;;;;;;75207:24;;;;;;;;:14;:24;;;;;;;75206:25;75198:34;;;;;;75251:24;;;;;;;;:14;:24;;;;;;;75243:33;;;;;;75297:22;;;;;;;;;:12;:22;;;;;:29;;-1:-1:-1;;75297:29:0;;;;;;;;;;75054:280::o;68380:46::-;;;;;;;;;;;;;:::o;68494:53::-;;;;;;;;;;;;;:::o;76117:117::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;76195:7;:31;;-1:-1:-1;;;;;;76195:31:0;-1:-1:-1;;;;;76195:31:0;;;;;;;;;;76117:117::o;76966:289::-;69160:24;;;;77153:4;69160:24;;;:14;:24;;;;;;77153:4;;77071:8;;69160:24;69152:60;;;;;-1:-1:-1;;;69152:60:0;;;;;;;;;;;;-1:-1:-1;;;69152:60:0;;;;;;;;;;;;;;;69231:22;;;;;;;;:12;:22;;;;;;;69223:56;;;;;-1:-1:-1;;;69223:56:0;;;;;;;;;;;;-1:-1:-1;;;69223:56:0;;;;;;;;;;;;;;;77090:7;77099:8;77109:9;77120:7;69462:15;;;;;;;;;;;69454:53;;;;;-1:-1:-1;;;69454:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;69518:16;69545:18;69599:27;69608:8;69618:7;69599:8;:27::i;:::-;69574:52;;-1:-1:-1;69574:52:0;-1:-1:-1;69645:12:0;69637:42;;;;;-1:-1:-1;;;69637:42:0;;;;;;;;;;;;-1:-1:-1;;;69637:42:0;;;;;;;;;;;;;;;69700:23;;;;;;;:13;:23;;;;;:34;;;69789:26;69797:10;69700:23;69789:7;:26::i;:::-;69773:42;;69857:5;69844:9;:18;;69836:53;;;;;-1:-1:-1;;;69836:53:0;;;;;;;;;;;;-1:-1:-1;;;69836:53:0;;;;;;;;;;;;;;;77170:7;;;;;;;;;-1:-1:-1;;;;;77170:7:0;-1:-1:-1;;;;;77170:15:0;;77186:9;77197:7;77206:8;77170:45;;;;;;;;;;;;;-1:-1:-1;;;;;77170:45:0;-1:-1:-1;;;;;77170:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;77170:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;77170:45:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;77243:4:0;;-1:-1:-1;;69948:5:0;69936:9;:17;69932:128;;;70021:27;;69987:9;:17;;;;70021:10;;:27;;;;;69987:17;;69970:14;70021:27;69970:14;70021:27;69987:17;70021:10;:27;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;70021:27:0;69932:128;;-1:-1:-1;;;;;70084:21:0;;;70080:668;;-1:-1:-1;;;;;70130:21:0;;70141:10;70130:21;;70122:66;;;;;-1:-1:-1;;;70122:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;70211:20:0;;70222:9;70211:20;;70203:76;;;;-1:-1:-1;;;70203:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70313:9;-1:-1:-1;;;;;70302:20:0;:7;-1:-1:-1;;;;;70302:20:0;;;70294:68;;;;-1:-1:-1;;;70294:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;70520:23:0;;70474:22;70520:23;;;:14;:23;;;;;;;70708:28;;67519:1;70499:44;;;;70607:3;70581:22;;;70580:30;;70520:23;;70708:28;;;;;70580:30;;70708:28;;70474:22;70708:28;70580:30;70520:23;70708:28;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;70708:28:0;70080:668;;;;69290:1;;;;;;;76966:289;;;;;;;:::o;76242:119::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;76322:7;:31;;-1:-1:-1;;;;;;76322:31:0;-1:-1:-1;;;;;76322:31:0;;;;;;;;;;76242:119::o;51717:109::-;50823:9;:7;:9::i;:::-;50815:54;;;;;-1:-1:-1;;;50815:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;50815:54:0;;;;;;;;;;;;;;;51790:28;51809:8;51790:18;:28::i;:::-;51717:109;:::o;68618:38::-;;;;;;:::o;68736:22::-;;;;;;-1:-1:-1;;;;;68736:22:0;;:::o;49402:98::-;49482:10;49402:98;:::o;51932:229::-;-1:-1:-1;;;;;52006:22:0;;51998:73;;;;-1:-1:-1;;;51998:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52108:6;;;52087:38;;-1:-1:-1;;;;;52087:38:0;;;;52108:6;;;52087:38;;;52136:6;:17;;-1:-1:-1;;;;;;52136:17:0;-1:-1:-1;;;;;52136:17:0;;;;;;;;;;51932:229::o

bzzr://d825db356607779dcbb56ceb6bcafae812457e25afb6d01fa2f3d4cd75379630