Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

pragma solidity 0.5.9;

import "../../contracts_common/src/Libraries/SafeMathWithRequire.sol";
import "../Land.sol";
import "../../contracts_common/src/Interfaces/ERC20.sol";
import "../../contracts_common/src/BaseWithStorage/MetaTransactionReceiver.sol";
import "../../contracts_common/src/Interfaces/Medianizer.sol";

/**
 * @title Land Sale contract that supports also DAI and ETH as payment
 * @notice This contract mananges the sale of our lands
 */
contract LandSaleWithETHAndDAI is MetaTransactionReceiver {
    using SafeMathWithRequire for uint256;

    uint256 internal constant GRID_SIZE = 408; // 408 is the size of the Land
    uint256 internal constant daiPrice = 14400000000000000;

    Land internal _land;
    ERC20 internal _sand;
    Medianizer private _medianizer;
    ERC20 private _dai;

    address payable internal _wallet;
    uint256 internal _expiryTime;
    bytes32 internal _merkleRoot;

    bool _sandEnabled = false;
    bool _etherEnabled = true;
    bool _daiEnabled = false;

    event LandQuadPurchased(
        address indexed buyer,
        address indexed to,
        uint256 indexed topCornerId,
        uint256 size,
        uint256 price,
        address token,
        uint256 amountPaid
    );

    constructor(
        address landAddress,
        address sandContractAddress,
        address initialMetaTx,
        address admin,
        address payable initialWalletAddress,
        bytes32 merkleRoot,
        uint256 expiryTime,
        address medianizerContractAddress,
        address daiTokenContractAddress
    ) public {
        _land = Land(landAddress);
        _sand = ERC20(sandContractAddress);
        _setMetaTransactionProcessor(initialMetaTx, true);
        _admin = admin;
        _wallet = initialWalletAddress;
        _merkleRoot = merkleRoot;
        _expiryTime = expiryTime;
        _medianizer = Medianizer(medianizerContractAddress);
        _dai = ERC20(daiTokenContractAddress);
    }

    /// @notice set the wallet receiving the proceeds
    /// @param newWallet address of the new receiving wallet
    function setReceivingWallet(address payable newWallet) external{
        require(newWallet != address(0), "receiving wallet cannot be zero address");
        require(msg.sender == _admin, "only admin can change the receiving wallet");
        _wallet = newWallet;
    }

    /// @notice enable/disable DAI payment for Lands
    /// @param enabled whether to enable or disable
    function setDAIEnabled(bool enabled) external {
        require(msg.sender == _admin, "only admin can enable/disable DAI");
        _daiEnabled = enabled;
    }

    /// @notice return whether DAI payments are enabled
    /// @return whether DAI payments are enabled
    function isDAIEnabled() external view returns (bool) {
        return _daiEnabled;
    }

    /// @notice enable/disable ETH payment for Lands
    /// @param enabled whether to enable or disable
    function setETHEnabled(bool enabled) external {
        require(msg.sender == _admin, "only admin can enable/disable ETH");
        _etherEnabled = enabled;
    }

    /// @notice return whether ETH payments are enabled
    /// @return whether ETH payments are enabled
    function isETHEnabled() external view returns (bool) {
        return _etherEnabled;
    }

    /// @notice enable/disable the specific SAND payment for Lands
    /// @param enabled whether to enable or disable
    function setSANDEnabled(bool enabled) external {
        require(msg.sender == _admin, "only admin can enable/disable SAND");
        _sandEnabled = enabled;
    }

    /// @notice return whether the specific SAND payments are enabled
    /// @return whether the specific SAND payments are enabled
    function isSANDEnabled() external view returns (bool) {
        return _sandEnabled;
    }

    function _checkValidity(
        address buyer,
        address reserved,
        uint256 x,
        uint256 y,
        uint256 size,
        uint256 price,
        bytes32 salt,
        bytes32[] memory proof
    ) internal view {
        /* solium-disable-next-line security/no-block-members */
        require(block.timestamp < _expiryTime, "sale is over");
        require(buyer == msg.sender || _metaTransactionContracts[msg.sender], "not authorized");
        require(reserved == address(0) || reserved == buyer, "cannot buy reserved Land");
        bytes32 leaf = _generateLandHash(x, y, size, price, reserved, salt);

        require(
            _verify(proof, leaf),
            "Invalid land provided"
        );
    }

    function _mint(address buyer, address to, uint256 x, uint256 y, uint256 size, uint256 price, address token, uint256 tokenAmount) internal {
        _land.mintQuad(to, size, x, y, "");
        emit LandQuadPurchased(buyer, to, x + (y * GRID_SIZE), size, price, token, tokenAmount);
    }

    /**
     * @notice buy Land with SAND using the merkle proof associated with it
     * @param buyer address that perform the payment
     * @param to address that will own the purchased Land
     * @param reserved the reserved address (if any)
     * @param x x coordinate of the Land
     * @param y y coordinate of the Land
     * @param size size of the pack of Land to purchase
     * @param priceInSand price in SAND to purchase that Land
     * @param proof merkleProof for that particular Land
     * @return The address of the operator
     */
    function buyLandWithSand(
        address buyer,
        address to,
        address reserved,
        uint256 x,
        uint256 y,
        uint256 size,
        uint256 priceInSand,
        bytes32 salt,
        bytes32[] calldata proof
    ) external {
        require(_sandEnabled, "sand payments not enabled");
        _checkValidity(buyer, reserved, x, y, size, priceInSand, salt, proof);
        require(
            _sand.transferFrom(
                buyer,
                _wallet,
                priceInSand
            ),
            "sand token transfer failed"
        );
        _mint(buyer, to, x, y, size, priceInSand, address(_sand), priceInSand);
    }

    /**
     * @notice buy Land with ETH using the merkle proof associated with it
     * @param buyer address that perform the payment
     * @param to address that will own the purchased Land
     * @param reserved the reserved address (if any)
     * @param x x coordinate of the Land
     * @param y y coordinate of the Land
     * @param size size of the pack of Land to purchase
     * @param priceInSand price in SAND to purchase that Land
     * @param proof merkleProof for that particular Land
     * @return The address of the operator
     */
    function buyLandWithETH(
        address buyer,
        address to,
        address reserved,
        uint256 x,
        uint256 y,
        uint256 size,
        uint256 priceInSand,
        bytes32 salt,
        bytes32[] calldata proof
    ) external payable {
        require(_etherEnabled, "ether payments not enabled");
        _checkValidity(buyer, reserved, x, y, size, priceInSand, salt, proof);

        uint256 ETHRequired = getEtherAmountWithSAND(priceInSand);
        require(msg.value >= ETHRequired, "not enough ether sent");
        uint256 leftOver = msg.value - ETHRequired;
        if(leftOver > 0) {
            msg.sender.transfer(leftOver); // refund extra
        }
        address(_wallet).transfer(ETHRequired);

        _mint(buyer, to, x, y, size, priceInSand, address(0), ETHRequired);
    }

    /**
     * @notice buy Land with DAI using the merkle proof associated with it
     * @param buyer address that perform the payment
     * @param to address that will own the purchased Land
     * @param reserved the reserved address (if any)
     * @param x x coordinate of the Land
     * @param y y coordinate of the Land
     * @param size size of the pack of Land to purchase
     * @param priceInSand price in SAND to purchase that Land
     * @param proof merkleProof for that particular Land
     * @return The address of the operator
     */
    function buyLandWithDAI(
        address buyer,
        address to,
        address reserved,
        uint256 x,
        uint256 y,
        uint256 size,
        uint256 priceInSand,
        bytes32 salt,
        bytes32[] calldata proof
    ) external {
        require(_daiEnabled, "dai payments not enabled");
        _checkValidity(buyer, reserved, x, y, size, priceInSand, salt, proof);

        uint256 DAIRequired = priceInSand.mul(daiPrice).div(1000000000000000000);
        require(_dai.transferFrom(msg.sender, _wallet, DAIRequired), "failed to transfer dai");

        _mint(buyer, to, x, y, size, priceInSand, address(_dai), DAIRequired);
    }

    /**
     * @notice Gets the expiry time for the current sale
     * @return The expiry time, as a unix epoch
     */
    function getExpiryTime() external view returns(uint256) {
        return _expiryTime;
    }

    /**
     * @notice Gets the Merkle root associated with the current sale
     * @return The Merkle root, as a bytes32 hash
     */
    function merkleRoot() external view returns(bytes32) {
        return _merkleRoot;
    }

    function _generateLandHash(
        uint256 x,
        uint256 y,
        uint256 size,
        uint256 price,
        address reserved,
        bytes32 salt
    ) internal pure returns (
        bytes32
    ) {
        return keccak256(
            abi.encodePacked(
                x,
                y,
                size,
                price,
                reserved,
                salt
            )
        );
    }

    function _verify(bytes32[] memory proof, bytes32 leaf) internal view returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (computedHash < proofElement) {
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        return computedHash == _merkleRoot;
    }

    /**
     * @notice Returns the amount of ETH for a specific amount of SAND
     * @param sandAmount An amount of SAND
     * @return The amount of ETH
     */
    function getEtherAmountWithSAND(uint256 sandAmount) public view returns (uint256) {
        uint256 ethUsdPair = getEthUsdPair();
        return sandAmount.mul(daiPrice).div(ethUsdPair);
    }

    /**
     * @notice Gets the ETHUSD pair from the Medianizer contract
     * @return The pair as an uint256
     */
    function getEthUsdPair() internal view returns (uint256) {
        bytes32 pair = _medianizer.read();
        return uint256(pair);
    }
}

pragma solidity ^0.5.2;

contract Admin {

    address internal _admin;

    event AdminChanged(address oldAdmin, address newAdmin);

    /// @notice gives the current administrator of this contract.
    /// @return the current administrator of this contract.
    function getAdmin() external view returns (address) {
        return _admin;
    }

    /// @notice change the administrator to be `newAdmin`.
    /// @param newAdmin address of the new administrator.
    function changeAdmin(address newAdmin) external {
        require(msg.sender == _admin, "only admin can change admin");
        emit AdminChanged(_admin, newAdmin);
        _admin = newAdmin;
    }

    modifier onlyAdmin() {
        require (msg.sender == _admin, "only admin allowed");
        _;
    }

}

pragma solidity ^0.5.2;

import "./Admin.sol";

contract MetaTransactionReceiver is Admin{

    mapping(address => bool) internal _metaTransactionContracts;
    event MetaTransactionProcessor(address metaTransactionProcessor, bool enabled);

    /// @notice Enable or disable the ability of `metaTransactionProcessor` to perform meta-tx (metaTransactionProcessor rights).
    /// @param metaTransactionProcessor address that will be given/removed metaTransactionProcessor rights.
    /// @param enabled set whether the metaTransactionProcessor is enabled or disabled.
    function setMetaTransactionProcessor(address metaTransactionProcessor, bool enabled) public {
        require(
            msg.sender == _admin,
            "only admin can setup metaTransactionProcessors"
        );
        _setMetaTransactionProcessor(metaTransactionProcessor, enabled);
    }

    function _setMetaTransactionProcessor(address metaTransactionProcessor, bool enabled) internal {
        _metaTransactionContracts[metaTransactionProcessor] = enabled;
        emit MetaTransactionProcessor(metaTransactionProcessor, enabled);
    }

    /// @notice check whether address `who` is given meta-transaction execution rights.
    /// @param who The address to query.
    /// @return whether the address has meta-transaction execution rights.
    function isMetaTransactionProcessor(address who) external view returns(bool) {
        return _metaTransactionContracts[who];
    }
}

pragma solidity ^0.5.2;

import "./Admin.sol";

contract SuperOperators is Admin {

    mapping(address => bool) internal _superOperators;

    event SuperOperator(address superOperator, bool enabled);

    /// @notice Enable or disable the ability of `superOperator` to transfer tokens of all (superOperator rights).
    /// @param superOperator address that will be given/removed superOperator right.
    /// @param enabled set whether the superOperator is enabled or disabled.
    function setSuperOperator(address superOperator, bool enabled) external {
        require(
            msg.sender == _admin,
            "only admin is allowed to add super operators"
        );
        _superOperators[superOperator] = enabled;
        emit SuperOperator(superOperator, enabled);
    }

    /// @notice check whether address `who` is given superOperator rights.
    /// @param who The address to query.
    /// @return whether the address has superOperator rights.
    function isSuperOperator(address who) public view returns (bool) {
        return _superOperators[who];
    }
}

pragma solidity ^0.5.2;

import "./ERC20Basic.sol";

/**
 * @title ERC20 interface
 * @dev see https://eips.ethereum.org/EIPS/eip-20
 */
/* interface */
contract ERC20 is ERC20Basic {
    function transferFrom(address from, address to, uint256 value)
        public
        returns (bool);
    function approve(address spender, uint256 value) public returns (bool);
    function allowance(address owner, address spender)
        public
        view
        returns (uint256);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

pragma solidity ^0.5.2;

/**
 * @title ERC20Basic DRAFT
 * @dev Simpler version of ERC20 interface
 * See https://github.com/ethereum/EIPs/issues/179
 */
/* interface */
contract ERC20Basic {
    function totalSupply() public view returns (uint256);
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
}

pragma solidity ^0.5.2;

/**
 * @title ERC721 Non-Fungible Token Standard basic interface
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
interface ERC721Events {
    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
    );
}

pragma solidity ^0.5.2;

/**
    Note: The ERC-165 identifier for this interface is 0x5e8bf644.
*/
interface ERC721MandatoryTokenReceiver {
    function onERC721BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        bytes calldata data
    ) external returns (bytes4); // needs to return 0x4b808c46

    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4); // needs to return 0x150b7a02

    // needs to implements EIP-165
    // function supportsInterface(bytes4 interfaceId)
    //     external
    //     view
    //     returns (bool);
}

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This code has not been reviewed.
 * Do not use or deploy this code before reviewing it personally first.
 */
// solhint-disable-next-line compiler-fixed
pragma solidity ^0.5.2;

interface ERC721TokenReceiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

pragma solidity ^0.5.2;


/**
 * @title Medianizer contract
 * @dev From MakerDAO (https://etherscan.io/address/0x729D19f657BD0614b4985Cf1D82531c67569197B#code)
 */
interface Medianizer {
    function read() external view returns (bytes32);
}

pragma solidity ^0.5.2;

library AddressUtils {

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

    function isContract(address addr) internal view returns (bool) {
        // for accounts without code, i.e. `keccak256('')`:
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;

        bytes32 codehash;
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            codehash := extcodehash(addr)
        }
        return (codehash != 0x0 && codehash != accountHash);
    }
}

pragma solidity ^0.5.2;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert
 */
library SafeMathWithRequire {
    /**
    * @dev Multiplies two numbers, throws on overflow.
    */
    function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
        // Gas optimization: this is cheaper than asserting 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        c = a * b;
        require(c / a == b, "overflow");
        return c;
    }

    /**
    * @dev Integer division of two numbers, truncating the quotient.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        // uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return a / b;
    }

    /**
    * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
    */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "undeflow");
        return a - b;
    }

    /**
    * @dev Adds two numbers, throws on overflow.
    */
    function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
        c = a + b;
        require(c >= a, "overflow");
        return c;
    }
}

/* solhint-disable no-empty-blocks */

pragma solidity 0.5.9;

import "./Land/erc721/LandBaseToken.sol";

contract Land is LandBaseToken {
    constructor(
        address metaTransactionContract,
        address admin
    ) public LandBaseToken(
        metaTransactionContract,
        admin
    ) {
    }

    /**
     * @notice Return the name of the token contract
     * @return The name of the token contract
     */
    function name() external pure returns (string memory) {
        return "Sandbox's LANDs";
    }

    /**
     * @notice Return the symbol of the token contract
     * @return The symbol of the token contract
     */
    function symbol() external pure returns (string memory) {
        return "LAND";
    }

    // solium-disable-next-line security/no-assign-params
    function uint2str(uint _i) internal pure returns (string memory) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (_i != 0) {
            bstr[k--] = byte(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }

    /**
     * @notice Return the URI of a specific token
     * @param id The id of the token
     * @return The URI of the token
     */
    function tokenURI(uint256 id) public view returns (string memory) {
        require(_ownerOf(id) != address(0), "Id does not exist");
        return
            string(
                abi.encodePacked(
                    "https://api.sandbox.game/lands/",
                    uint2str(id),
                    "/metadata.json"
                )
            );
    }

    /**
     * @notice Check if the contract supports an interface
     * 0x01ffc9a7 is ERC-165
     * 0x80ac58cd is ERC-721
     * 0x5b5e139f is ERC-721 metadata
     * @param id The id of the interface
     * @return True if the interface is supported
     */
    function supportsInterface(bytes4 id) external pure returns (bool) {
        return id == 0x01ffc9a7 || id == 0x80ac58cd || id == 0x5b5e139f;
    }
}

/* solhint-disable func-order, code-complexity */
pragma solidity 0.5.9;

import "../../../contracts_common/src/Libraries/AddressUtils.sol";
import "../../../contracts_common/src/Interfaces/ERC721TokenReceiver.sol";
import "../../../contracts_common/src/Interfaces/ERC721Events.sol";
import "../../../contracts_common/src/BaseWithStorage/SuperOperators.sol";
import "../../../contracts_common/src/BaseWithStorage/MetaTransactionReceiver.sol";
import "../../../contracts_common/src/Interfaces/ERC721MandatoryTokenReceiver.sol";

contract ERC721BaseToken is ERC721Events, SuperOperators, MetaTransactionReceiver {
    using AddressUtils for address;

    bytes4 internal constant _ERC721_RECEIVED = 0x150b7a02;
    bytes4 internal constant _ERC721_BATCH_RECEIVED = 0x4b808c46;

    bytes4 internal constant ERC165ID = 0x01ffc9a7;
    bytes4 internal constant ERC721_MANDATORY_RECEIVER = 0x5e8bf644;

    mapping (address => uint256) public _numNFTPerAddress;
    mapping (uint256 => uint256) public _owners;
    mapping (address => mapping(address => bool)) public _operatorsForAll;
    mapping (uint256 => address) public _operators;

    constructor(
        address metaTransactionContract,
        address admin
    ) internal {
        _admin = admin;
        _setMetaTransactionProcessor(metaTransactionContract, true);
    }

    function _transferFrom(address from, address to, uint256 id) internal {
        _numNFTPerAddress[from]--;
        _numNFTPerAddress[to]++;
        _owners[id] = uint256(to);
        emit Transfer(from, to, id);
    }

    /**
     * @notice Return the number of Land owned by an address
     * @param owner The address to look for
     * @return The number of Land token owned by the address
     */
    function balanceOf(address owner) external view returns (uint256) {
        require(owner != address(0), "owner is zero address");
        return _numNFTPerAddress[owner];
    }


    function _ownerOf(uint256 id) internal view returns (address) {
        return address(_owners[id]);
    }

    function _ownerAndOperatorEnabledOf(uint256 id) internal view returns (address owner, bool operatorEnabled) {
        uint256 data = _owners[id];
        owner = address(data);
        operatorEnabled = (data / 2**255) == 1;
    }

    /**
     * @notice Return the owner of a Land
     * @param id The id of the Land
     * @return The address of the owner
     */
    function ownerOf(uint256 id) external view returns (address owner) {
        owner = _ownerOf(id);
        require(owner != address(0), "token does not exist");
    }

    function _approveFor(address owner, address operator, uint256 id) internal {
        if(operator == address(0)) {
            _owners[id] = uint256(owner); // no need to resset the operator, it will be overriden next time
        } else {
            _owners[id] = uint256(owner) + 2**255;
            _operators[id] = operator;
        }
        emit Approval(owner, operator, id);
    }

    /**
     * @notice Approve an operator to spend tokens on the sender behalf
     * @param sender The address giving the approval
     * @param operator The address receiving the approval
     * @param id The id of the token
     */
    function approveFor(
        address sender,
        address operator,
        uint256 id
    ) external {
        address owner = _ownerOf(id);
        require(sender != address(0), "sender is zero address");
        require(
            msg.sender == sender ||
            _metaTransactionContracts[msg.sender] ||
            _superOperators[msg.sender] ||
            _operatorsForAll[sender][msg.sender],
            "not authorized to approve"
        );
        require(owner == sender, "owner != sender");
        _approveFor(owner, operator, id);
    }

    /**
     * @notice Approve an operator to spend tokens on the sender behalf
     * @param operator The address receiving the approval
     * @param id The id of the token
     */
    function approve(address operator, uint256 id) external {
        address owner = _ownerOf(id);
        require(owner != address(0), "token does not exist");
        require(
            owner == msg.sender ||
            _superOperators[msg.sender] ||
            _operatorsForAll[owner][msg.sender],
            "not authorized to approve"
        );
        _approveFor(owner, operator, id);
    }

    /**
     * @notice Get the approved operator for a specific token
     * @param id The id of the token
     * @return The address of the operator
     */
    function getApproved(uint256 id) external view returns (address) {
        (address owner, bool operatorEnabled) = _ownerAndOperatorEnabledOf(id);
        require(owner != address(0), "token does not exist");
        if (operatorEnabled) {
            return _operators[id];
        } else {
            return address(0);
        }
    }

    function _checkTransfer(address from, address to, uint256 id) internal view returns (bool isMetaTx) {
        (address owner, bool operatorEnabled) = _ownerAndOperatorEnabledOf(id);
        require(owner != address(0), "token does not exist");
        require(owner == from, "not owner in _checkTransfer");
        require(to != address(0), "can't send to zero address");
        isMetaTx = msg.sender != from && _metaTransactionContracts[msg.sender];
        if (msg.sender != from && !isMetaTx) {
            require(
                _superOperators[msg.sender] ||
                _operatorsForAll[from][msg.sender] ||
                (operatorEnabled && _operators[id] == msg.sender),
                "not approved to transfer"
            );
        }
    }

    function _checkInterfaceWith10000Gas(address _contract, bytes4 interfaceId)
        internal
        view
        returns (bool)
    {
        bool success;
        bool result;
        bytes memory call_data = abi.encodeWithSelector(
            ERC165ID,
            interfaceId
        );
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            let call_ptr := add(0x20, call_data)
            let call_size := mload(call_data)
            let output := mload(0x40) // Find empty storage location using "free memory pointer"
            mstore(output, 0x0)
            success := staticcall(
                10000,
                _contract,
                call_ptr,
                call_size,
                output,
                0x20
            ) // 32 bytes
            result := mload(output)
        }
        // (10000 / 63) "not enough for supportsInterface(...)" // consume all gas, so caller can potentially know that there was not enough gas
        assert(gasleft() > 158);
        return success && result;
    }

    /**
     * @notice Transfer a token between 2 addresses
     * @param from The sender of the token
     * @param to The recipient of the token
     * @param id The id of the token
    */
    function transferFrom(address from, address to, uint256 id) external {
        bool metaTx = _checkTransfer(from, to, id);
        _transferFrom(from, to, id);
        if (to.isContract() && _checkInterfaceWith10000Gas(to, ERC721_MANDATORY_RECEIVER)) {
            require(
                _checkOnERC721Received(metaTx ? from : msg.sender, from, to, id, ""),
                "erc721 transfer rejected by to"
            );
        }
    }

    /**
     * @notice Transfer a token between 2 addresses letting the receiver knows of the transfer
     * @param from The sender of the token
     * @param to The recipient of the token
     * @param id The id of the token
     * @param data Additional data
     */
    function safeTransferFrom(address from, address to, uint256 id, bytes memory data) public {
        bool metaTx = _checkTransfer(from, to, id);
        _transferFrom(from, to, id);
        if (to.isContract()) {
            require(
                _checkOnERC721Received(metaTx ? from : msg.sender, from, to, id, data),
                "ERC721: transfer rejected by to"
            );
        }
    }

    /**
     * @notice Transfer a token between 2 addresses letting the receiver knows of the transfer
     * @param from The send of the token
     * @param to The recipient of the token
     * @param id The id of the token
     */
    function safeTransferFrom(address from, address to, uint256 id) external {
        safeTransferFrom(from, to, id, "");
    }

    /**
     * @notice Transfer many tokens between 2 addresses
     * @param from The sender of the token
     * @param to The recipient of the token
     * @param ids The ids of the tokens
     * @param data additional data
    */
    function batchTransferFrom(address from, address to, uint256[] calldata ids, bytes calldata data) external {
        _batchTransferFrom(from, to, ids, data, false);
    }

    function _batchTransferFrom(address from, address to, uint256[] memory ids, bytes memory data, bool safe) internal {
        bool metaTx = msg.sender != from && _metaTransactionContracts[msg.sender];
        bool authorized = msg.sender == from ||
            metaTx ||
            _superOperators[msg.sender] ||
            _operatorsForAll[from][msg.sender];

        require(from != address(0), "from is zero address");
        require(to != address(0), "can't send to zero address");

        uint256 numTokens = ids.length;
        for(uint256 i = 0; i < numTokens; i ++) {
            uint256 id = ids[i];
            (address owner, bool operatorEnabled) = _ownerAndOperatorEnabledOf(id);
            require(owner == from, "not owner in batchTransferFrom");
            require(authorized || (operatorEnabled && _operators[id] == msg.sender), "not authorized");
            _owners[id] = uint256(to);
            emit Transfer(from, to, id);
        }
        if (from != to) {
            _numNFTPerAddress[from] -= numTokens;
            _numNFTPerAddress[to] += numTokens;
        }

        if (to.isContract() && (safe || _checkInterfaceWith10000Gas(to, ERC721_MANDATORY_RECEIVER))) {
            require(
                _checkOnERC721BatchReceived(metaTx ? from : msg.sender, from, to, ids, data),
                "erc721 batch transfer rejected by to"
            );
        }
    }

    /**
     * @notice Transfer many tokens between 2 addresses ensuring the receiving contract has a receiver method
     * @param from The sender of the token
     * @param to The recipient of the token
     * @param ids The ids of the tokens
     * @param data additional data
    */
    function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, bytes calldata data) external {
        _batchTransferFrom(from, to, ids, data, true);
    }

    /**
     * @notice Check if the contract supports an interface
     * 0x01ffc9a7 is ERC-165
     * 0x80ac58cd is ERC-721
     * @param id The id of the interface
     * @return True if the interface is supported
     */
    function supportsInterface(bytes4 id) external pure returns (bool) {
        return id == 0x01ffc9a7 || id == 0x80ac58cd;
    }

    /**
     * @notice Set the approval for an operator to manage all the tokens of the sender
     * @param sender The address giving the approval
     * @param operator The address receiving the approval
     * @param approved The determination of the approval
     */
    function setApprovalForAllFor(
        address sender,
        address operator,
        bool approved
    ) external {
        require(sender != address(0), "Invalid sender address");
        require(
            msg.sender == sender ||
            _metaTransactionContracts[msg.sender] ||
            _superOperators[msg.sender],
            "not authorized to approve for all"
        );

        _setApprovalForAll(sender, operator, approved);
    }

    /**
     * @notice Set the approval for an operator to manage all the tokens of the sender
     * @param operator The address receiving the approval
     * @param approved The determination of the approval
     */
    function setApprovalForAll(address operator, bool approved) external {
        _setApprovalForAll(msg.sender, operator, approved);
    }


    function _setApprovalForAll(
        address sender,
        address operator,
        bool approved
    ) internal {
        require(
            !_superOperators[operator],
            "super operator can't have their approvalForAll changed"
        );
        _operatorsForAll[sender][operator] = approved;

        emit ApprovalForAll(sender, operator, approved);
    }

    /**
     * @notice Check if the sender approved the operator
     * @param owner The address of the owner
     * @param operator The address of the operator
     * @return The status of the approval
     */
    function isApprovedForAll(address owner, address operator)
        external
        view
        returns (bool isOperator)
    {
        return _operatorsForAll[owner][operator] || _superOperators[operator];
    }

    function _burn(address from, address owner, uint256 id) public {
        require(from == owner, "not owner");
        _owners[id] = 2**160; // cannot mint it again
        _numNFTPerAddress[from]--;
        emit Transfer(from, address(0), id);
    }

    /// @notice Burns token `id`.
    /// @param id token which will be burnt.
    function burn(uint256 id) external {
        _burn(msg.sender, _ownerOf(id), id);
    }

    /// @notice Burn token`id` from `from`.
    /// @param from address whose token is to be burnt.
    /// @param id token which will be burnt.
    function burnFrom(address from, uint256 id) external {
        require(from != address(0), "Invalid sender address");
        (address owner, bool operatorEnabled) = _ownerAndOperatorEnabledOf(id);
        require(
            msg.sender == from ||
            _metaTransactionContracts[msg.sender] ||
            (operatorEnabled && _operators[id] == msg.sender) ||
            _superOperators[msg.sender] ||
            _operatorsForAll[from][msg.sender],
            "not authorized to burn"
        );
        _burn(from, owner, id);
    }

    function _checkOnERC721Received(address operator, address from, address to, uint256 tokenId, bytes memory _data)
        internal returns (bool)
    {
        bytes4 retval = ERC721TokenReceiver(to).onERC721Received(operator, from, tokenId, _data);
        return (retval == _ERC721_RECEIVED);
    }

    function _checkOnERC721BatchReceived(address operator, address from, address to, uint256[] memory ids, bytes memory _data)
        internal returns (bool)
    {
        bytes4 retval = ERC721MandatoryTokenReceiver(to).onERC721BatchReceived(operator, from, ids, _data);
        return (retval == _ERC721_BATCH_RECEIVED);
    }
}

/* solhint-disable func-order, code-complexity */
pragma solidity 0.5.9;

import "./ERC721BaseToken.sol";

contract LandBaseToken is ERC721BaseToken {
    // Our grid is 408 x 408 lands
    uint256 internal constant GRID_SIZE = 408;

    uint256 internal constant LAYER =          0xFF00000000000000000000000000000000000000000000000000000000000000;
    uint256 internal constant LAYER_1x1 =      0x0000000000000000000000000000000000000000000000000000000000000000;
    uint256 internal constant LAYER_3x3 =      0x0100000000000000000000000000000000000000000000000000000000000000;
    uint256 internal constant LAYER_6x6 =      0x0200000000000000000000000000000000000000000000000000000000000000;
    uint256 internal constant LAYER_12x12 =    0x0300000000000000000000000000000000000000000000000000000000000000;
    uint256 internal constant LAYER_24x24 =    0x0400000000000000000000000000000000000000000000000000000000000000;

    mapping(address => bool) internal _minters;
    event Minter(address superOperator, bool enabled);

    /// @notice Enable or disable the ability of `minter` to mint tokens
    /// @param minter address that will be given/removed minter right.
    /// @param enabled set whether the minter is enabled or disabled.
    function setMinter(address minter, bool enabled) external {
        require(
            msg.sender == _admin,
            "only admin is allowed to add minters"
        );
        _minters[minter] = enabled;
        emit Minter(minter, enabled);
    }

    /// @notice check whether address `who` is given minter rights.
    /// @param who The address to query.
    /// @return whether the address has minter rights.
    function isMinter(address who) public view returns (bool) {
        return _minters[who];
    }

    constructor(
        address metaTransactionContract,
        address admin
    ) public ERC721BaseToken(metaTransactionContract, admin) {
    }

    /// @notice total width of the map
    /// @return width
    function width() external returns(uint256) {
        return GRID_SIZE;
    }

    /// @notice total height of the map
    /// @return height
    function height() external returns(uint256) {
        return GRID_SIZE;
    }

    /// @notice x coordinate of Land token
    /// @param id tokenId
    /// @return the x coordinates
    function x(uint256 id) external returns(uint256) {
        require(_ownerOf(id) != address(0), "token does not exist");
        return id % GRID_SIZE;
    }

    /// @notice y coordinate of Land token
    /// @param id tokenId
    /// @return the y coordinates
    function y(uint256 id) external returns(uint256) {
        require(_ownerOf(id) != address(0), "token does not exist");
        return id / GRID_SIZE;
    }

    /**
     * @notice Mint a new quad (aligned to a quad tree with size 3, 6, 12 or 24 only)
     * @param to The recipient of the new quad
     * @param size The size of the new quad
     * @param x The top left x coordinate of the new quad
     * @param y The top left y coordinate of the new quad
     * @param data extra data to pass to the transfer
     */
    function mintQuad(address to, uint256 size, uint256 x, uint256 y, bytes calldata data) external {
        require(to != address(0), "to is zero address");
        require(
            isMinter(msg.sender),
            "Only a minter can mint"
        );
        require(x % size == 0 && y % size == 0, "Invalid coordinates");
        require(x <= GRID_SIZE - size && y <= GRID_SIZE - size, "Out of bounds");

        uint256 quadId;
        uint256 id = x + y * GRID_SIZE;

        if (size == 1) {
            quadId = id;
        } else if (size == 3) {
            quadId = LAYER_3x3 + id;
        } else if (size == 6) {
            quadId = LAYER_6x6 + id;
        } else if (size == 12) {
            quadId = LAYER_12x12 + id;
        } else if (size == 24) {
            quadId = LAYER_24x24 + id;
        } else {
            require(false, "Invalid size");
        }

        require(_owners[LAYER_24x24 + (x/24) * 24 + ((y/24) * 24) * GRID_SIZE] == 0, "Already minted as 24x24");

        uint256 toX = x+size;
        uint256 toY = y+size;
        if (size <= 12) {
            require(
                _owners[LAYER_12x12 + (x/12) * 12 + ((y/12) * 12) * GRID_SIZE] == 0,
                "Already minted as 12x12"
            );
        } else {
            for (uint256 x12i = x; x12i < toX; x12i += 12) {
                for (uint256 y12i = y; y12i < toY; y12i += 12) {
                    uint256 id12x12 = LAYER_12x12 + x12i + y12i * GRID_SIZE;
                    require(_owners[id12x12] == 0, "Already minted as 12x12");
                }
            }
        }

        if (size <= 6) {
            require(_owners[LAYER_6x6 + (x/6) * 6 + ((y/6) * 6) * GRID_SIZE] == 0, "Already minted as 6x6");
        } else {
            for (uint256 x6i = x; x6i < toX; x6i += 6) {
                for (uint256 y6i = y; y6i < toY; y6i += 6) {
                    uint256 id6x6 = LAYER_6x6 + x6i + y6i * GRID_SIZE;
                    require(_owners[id6x6] == 0, "Already minted as 6x6");
                }
            }
        }

        if (size <= 3) {
            require(_owners[LAYER_3x3 + (x/3) * 3 + ((y/3) * 3) * GRID_SIZE] == 0, "Already minted as 3x3");
        } else {
            for (uint256 x3i = x; x3i < toX; x3i += 3) {
                for (uint256 y3i = y; y3i < toY; y3i += 3) {
                    uint256 id3x3 = LAYER_3x3 + x3i + y3i * GRID_SIZE;
                    require(_owners[id3x3] == 0, "Already minted as 3x3");
                }
            }
        }

        for (uint256 i = 0; i < size*size; i++) {
            uint256 id = _idInPath(i, size, x, y);
            require(_owners[id] == 0, "Already minted");
            emit Transfer(address(0), to, id);
        }

        _owners[quadId] = uint256(to);
        _numNFTPerAddress[to] += size * size;

        _checkBatchReceiverAcceptQuad(msg.sender, address(0), to, size, x, y, data);
    }

    function _idInPath(uint256 i, uint256 size, uint256 x, uint256 y) internal pure returns(uint256) {
        uint256 row = i / size;
        if(row % 2 == 0) { // alow ids to follow a path in a quad
            return (x + (i%size)) + ((y + row) * GRID_SIZE);
        } else {
            return ((x + size) - (1 + i%size)) + ((y + row) * GRID_SIZE);
        }
    }

    /// @notice transfer one quad (aligned to a quad tree with size 3, 6, 12 or 24 only)
    /// @param from current owner of the quad
    /// @param to destination
    /// @param size size of the quad
    /// @param x The top left x coordinate of the quad
    /// @param y The top left y coordinate of the quad
    /// @param data additional data
    function transferQuad(address from, address to, uint256 size, uint256 x, uint256 y, bytes calldata data) external {
        require(from != address(0), "from is zero address");
        require(to != address(0), "can't send to zero address");
        bool metaTx = msg.sender != from && _metaTransactionContracts[msg.sender];
        if (msg.sender != from && !metaTx) {
            require(
                _superOperators[msg.sender] ||
                _operatorsForAll[from][msg.sender],
                "not authorized to transferQuad"
            );
        }
        _transferQuad(from, to, size, x, y);
        _numNFTPerAddress[from] -= size * size;
        _numNFTPerAddress[to] += size * size;

        _checkBatchReceiverAcceptQuad(metaTx ? from : msg.sender, from, to, size, x, y, data);
    }

    function _checkBatchReceiverAcceptQuad(
        address operator,
        address from,
        address to,
        uint256 size,
        uint256 x,
        uint256 y,
        bytes memory data
    ) internal {
        if (to.isContract() && _checkInterfaceWith10000Gas(to, ERC721_MANDATORY_RECEIVER)) {
            uint256[] memory ids = new uint256[](size*size);
            for (uint256 i = 0; i < size*size; i++) {
                ids[i] = _idInPath(i, size, x, y);
            }
            require(
                _checkOnERC721BatchReceived(operator, from, to, ids, data),
                "erc721 batch transfer rejected by to"
            );
        }
    }

    /// @notice transfer multiple quad (aligned to a quad tree with size 3, 6, 12 or 24 only)
    /// @param from current owner of the quad
    /// @param to destination
    /// @param sizes list of sizes for each quad
    /// @param xs list of top left x coordinates for each quad
    /// @param ys list of top left y coordinates for each quad
    /// @param data additional data
    function batchTransferQuad(
        address from,
        address to,
        uint256[] calldata sizes,
        uint256[] calldata xs,
        uint256[] calldata ys,
        bytes calldata data
    ) external {
        require(from != address(0), "from is zero address");
        require(to != address(0), "can't send to zero address");
        require(sizes.length == xs.length && xs.length == ys.length, "invalid data");
        bool metaTx = msg.sender != from && _metaTransactionContracts[msg.sender];
        if (msg.sender != from && !metaTx) {
            require(
                _superOperators[msg.sender] ||
                _operatorsForAll[from][msg.sender],
                "not authorized to transferMultiQuads"
            );
        }
        uint256 numTokensTransfered = 0;
        for (uint256 i = 0; i < sizes.length; i++) {
            uint256 size = sizes[i];
            _transferQuad(from, to, size, xs[i], ys[i]);
            numTokensTransfered += size * size;
        }
        _numNFTPerAddress[from] -= numTokensTransfered;
        _numNFTPerAddress[to] += numTokensTransfered;

        if (to.isContract() && _checkInterfaceWith10000Gas(to, ERC721_MANDATORY_RECEIVER)) {
            uint256[] memory ids = new uint256[](numTokensTransfered);
            uint256 counter = 0;
            for (uint256 j = 0; j < sizes.length; j++) {
                uint256 size = sizes[j];
                for (uint256 i = 0; i < size*size; i++) {
                    ids[counter] = _idInPath(i, size, xs[j], ys[j]);
                    counter++;
                }
            }
            require(
                _checkOnERC721BatchReceived(metaTx ? from : msg.sender, from, to, ids, data),
                "erc721 batch transfer rejected by to"
            );
        }
    }

    function _transferQuad(address from, address to, uint256 size, uint256 x, uint256 y) internal {
        if (size == 1) {
            uint256 id1x1 = x + y * GRID_SIZE;
            address owner = _ownerOf(id1x1);
            require(owner != address(0), "token does not exist");
            require(owner == from, "not owner in _transferQuad");
            _owners[id1x1] = uint256(to);
        } else {
            _regroup(from, to, size, x, y);
        }
        for (uint256 i = 0; i < size*size; i++) {
            emit Transfer(from, to, _idInPath(i, size, x, y));
        }
    }

    function _checkAndClear(address from, uint256 id) internal returns(bool) {
        uint256 owner = _owners[id];
        if (owner != 0) {
            require(address(owner) == from, "not owner");
            _owners[id] = 0;
            return true;
        }
        return false;
    }

    function _regroup(address from, address to, uint256 size, uint256 x, uint256 y) internal {
        require(x % size == 0 && y % size == 0, "Invalid coordinates");
        require(x <= GRID_SIZE - size && y <= GRID_SIZE - size, "Out of bounds");

        if (size == 3) {
            _regroup3x3(from, to, x, y, true);
        } else if (size == 6) {
            _regroup6x6(from, to, x, y, true);
        } else if (size == 12) {
            _regroup12x12(from, to, x, y, true);
        } else if (size == 24) {
            _regroup24x24(from, to, x, y, true);
        } else {
            require(false, "Invalid size");
        }
    }

    function _regroup3x3(address from, address to, uint256 x, uint256 y, bool set) internal returns (bool) {
        uint256 id = x + y * GRID_SIZE;
        uint256 quadId = LAYER_3x3 + id;
        bool ownerOfAll = true;
        for (uint256 xi = x; xi < x+3; xi++) {
            for (uint256 yi = y; yi < y+3; yi++) {
                ownerOfAll = _checkAndClear(from, xi + yi * GRID_SIZE) && ownerOfAll;
            }
        }
        if(set) {
            if(!ownerOfAll) {
                require(
                    _owners[quadId] == uint256(from) ||
                    _owners[LAYER_6x6 + (x/6) * 6 + ((y/6) * 6) * GRID_SIZE] == uint256(from) ||
                    _owners[LAYER_12x12 + (x/12) * 12 + ((y/12) * 12) * GRID_SIZE] == uint256(from) ||
                    _owners[LAYER_24x24 + (x/24) * 24 + ((y/24) * 24) * GRID_SIZE] == uint256(from),
                    "not owner of all sub quads nor parent quads"
                );
            }
            _owners[quadId] = uint256(to);
            return true;
        }
        return ownerOfAll;
    }
    function _regroup6x6(address from, address to, uint256 x, uint256 y, bool set) internal returns (bool) {
        uint256 id = x + y * GRID_SIZE;
        uint256 quadId = LAYER_6x6 + id;
        bool ownerOfAll = true;
        for (uint256 xi = x; xi < x+6; xi += 3) {
            for (uint256 yi = y; yi < y+6; yi += 3) {
                bool ownAllIndividual = _regroup3x3(from, to, xi, yi, false);
                uint256 id3x3 = LAYER_3x3 + xi + yi * GRID_SIZE;
                uint256 owner3x3 = _owners[id3x3];
                if (owner3x3 != 0) {
                    if(!ownAllIndividual) {
                        require(owner3x3 == uint256(from), "not owner of 3x3 quad");
                    }
                    _owners[id3x3] = 0;
                }
                ownerOfAll = (ownAllIndividual || owner3x3 != 0) && ownerOfAll;
            }
        }
        if(set) {
            if(!ownerOfAll) {
                require(
                    _owners[quadId] == uint256(from) ||
                    _owners[LAYER_12x12 + (x/12) * 12 + ((y/12) * 12) * GRID_SIZE] == uint256(from) ||
                    _owners[LAYER_24x24 + (x/24) * 24 + ((y/24) * 24) * GRID_SIZE] == uint256(from),
                    "not owner of all sub quads nor parent quads"
                );
            }
            _owners[quadId] = uint256(to);
            return true;
        }
        return ownerOfAll;
    }
    function _regroup12x12(address from, address to, uint256 x, uint256 y, bool set) internal returns (bool) {
        uint256 id = x + y * GRID_SIZE;
        uint256 quadId = LAYER_12x12 + id;
        bool ownerOfAll = true;
        for (uint256 xi = x; xi < x+12; xi += 6) {
            for (uint256 yi = y; yi < y+12; yi += 6) {
                bool ownAllIndividual = _regroup6x6(from, to, xi, yi, false);
                uint256 id6x6 = LAYER_6x6 + xi + yi * GRID_SIZE;
                uint256 owner6x6 = _owners[id6x6];
                if (owner6x6 != 0) {
                    if(!ownAllIndividual) {
                        require(owner6x6 == uint256(from), "not owner of 6x6 quad");
                    }
                    _owners[id6x6] = 0;
                }
                ownerOfAll = (ownAllIndividual || owner6x6 != 0) && ownerOfAll;
            }
        }
        if(set) {
            if(!ownerOfAll) {
                require(
                    _owners[quadId] == uint256(from) ||
                    _owners[LAYER_24x24 + (x/24) * 24 + ((y/24) * 24) * GRID_SIZE] == uint256(from),
                    "not owner of all sub quads nor parent quads"
                );
            }
            _owners[quadId] = uint256(to);
            return true;
        }
        return ownerOfAll;
    }
    function _regroup24x24(address from, address to, uint256 x, uint256 y, bool set) internal returns (bool) {
        uint256 id = x + y * GRID_SIZE;
        uint256 quadId = LAYER_24x24 + id;
        bool ownerOfAll = true;
        for (uint256 xi = x; xi < x+24; xi += 12) {
            for (uint256 yi = y; yi < y+24; yi += 12) {
                bool ownAllIndividual = _regroup12x12(from, to, xi, yi, false);
                uint256 id12x12 = LAYER_12x12 + xi + yi * GRID_SIZE;
                uint256 owner12x12 = _owners[id12x12];
                if (owner12x12 != 0) {
                    if(!ownAllIndividual) {
                        require(owner12x12 == uint256(from), "not owner of 12x12 quad");
                    }
                    _owners[id12x12] = 0;
                }
                ownerOfAll = (ownAllIndividual || owner12x12 != 0) && ownerOfAll;
            }
        }
        if(set) {
            if(!ownerOfAll) {
                require(
                    _owners[quadId] == uint256(from),
                    "not owner of all sub quads not parent quad"
                );
            }
            _owners[quadId] = uint256(to);
            return true;
        }
        return ownerOfAll || _owners[quadId] == uint256(from);
    }

    function _ownerOf(uint256 id) internal view returns (address) {
        require(id & LAYER == 0, "Invalid token id");
        uint256 x = id % GRID_SIZE;
        uint256 y = id / GRID_SIZE;
        uint256 owner1x1 = _owners[id];

        if (owner1x1 != 0) {
            return address(owner1x1); // cast to zero
        } else {
            address owner3x3 = address(_owners[LAYER_3x3 + (x/3) * 3 + ((y/3) * 3) * GRID_SIZE]);
            if (owner3x3 != address(0)) {
                return owner3x3;
            } else {
                address owner6x6 = address(_owners[LAYER_6x6 + (x/6) * 6 + ((y/6) * 6) * GRID_SIZE]);
                if (owner6x6 != address(0)) {
                    return owner6x6;
                } else {
                    address owner12x12 = address(_owners[LAYER_12x12 + (x/12) * 12 + ((y/12) * 12) * GRID_SIZE]);
                    if (owner12x12 != address(0)) {
                        return owner12x12;
                    } else {
                        return address(_owners[LAYER_24x24 + (x/24) * 24 + ((y/24) * 24) * GRID_SIZE]);
                    }
                }
            }
        }
    }

    function _ownerAndOperatorEnabledOf(uint256 id) internal view returns (address owner, bool operatorEnabled) {
        require(id & LAYER == 0, "Invalid token id");
        uint256 x = id % GRID_SIZE;
        uint256 y = id / GRID_SIZE;
        uint256 owner1x1 = _owners[id];

        if (owner1x1 != 0) {
            owner = address(owner1x1);
            operatorEnabled = (owner1x1 / 2**255) == 1;
        } else {
            address owner3x3 = address(_owners[LAYER_3x3 + (x/3) * 3 + ((y/3) * 3) * GRID_SIZE]);
            if (owner3x3 != address(0)) {
                owner = owner3x3;
                operatorEnabled = false;
            } else {
                address owner6x6 = address(_owners[LAYER_6x6 + (x/6) * 6 + ((y/6) * 6) * GRID_SIZE]);
                if (owner6x6 != address(0)) {
                    owner = owner6x6;
                    operatorEnabled = false;
                } else {
                    address owner12x12 = address(_owners[LAYER_12x12 + (x/12) * 12 + ((y/12) * 12) * GRID_SIZE]);
                    if (owner12x12 != address(0)) {
                        owner = owner12x12;
                        operatorEnabled = false;
                    } else {
                        owner = address(_owners[LAYER_24x24 + (x/24) * 24 + ((y/24) * 24) * GRID_SIZE]);
                        operatorEnabled = false;
                    }
                }
            }
        }
    }

}

{
  "evmVersion": "petersburg",
  "libraries": {},
  "metadata": {
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 2000
  },
  "remappings": [],
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"getExpiryTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"merkleRoot","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"enabled","type":"bool"}],"name":"setDAIEnabled","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"isDAIEnabled","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isETHEnabled","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"sandAmount","type":"uint256"}],"name":"getEtherAmountWithSAND","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"buyer","type":"address"},{"name":"to","type":"address"},{"name":"reserved","type":"address"},{"name":"x","type":"uint256"},{"name":"y","type":"uint256"},{"name":"size","type":"uint256"},{"name":"priceInSand","type":"uint256"},{"name":"salt","type":"bytes32"},{"name":"proof","type":"bytes32[]"}],"name":"buyLandWithDAI","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getAdmin","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"enabled","type":"bool"}],"name":"setSANDEnabled","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"metaTransactionProcessor","type":"address"},{"name":"enabled","type":"bool"}],"name":"setMetaTransactionProcessor","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"newAdmin","type":"address"}],"name":"changeAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"isSANDEnabled","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"newWallet","type":"address"}],"name":"setReceivingWallet","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"who","type":"address"}],"name":"isMetaTransactionProcessor","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"buyer","type":"address"},{"name":"to","type":"address"},{"name":"reserved","type":"address"},{"name":"x","type":"uint256"},{"name":"y","type":"uint256"},{"name":"size","type":"uint256"},{"name":"priceInSand","type":"uint256"},{"name":"salt","type":"bytes32"},{"name":"proof","type":"bytes32[]"}],"name":"buyLandWithSand","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"enabled","type":"bool"}],"name":"setETHEnabled","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"buyer","type":"address"},{"name":"to","type":"address"},{"name":"reserved","type":"address"},{"name":"x","type":"uint256"},{"name":"y","type":"uint256"},{"name":"size","type":"uint256"},{"name":"priceInSand","type":"uint256"},{"name":"salt","type":"bytes32"},{"name":"proof","type":"bytes32[]"}],"name":"buyLandWithETH","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"inputs":[{"name":"landAddress","type":"address"},{"name":"sandContractAddress","type":"address"},{"name":"initialMetaTx","type":"address"},{"name":"admin","type":"address"},{"name":"initialWalletAddress","type":"address"},{"name":"merkleRoot","type":"bytes32"},{"name":"expiryTime","type":"uint256"},{"name":"medianizerContractAddress","type":"address"},{"name":"daiTokenContractAddress","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"buyer","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":true,"name":"topCornerId","type":"uint256"},{"indexed":false,"name":"size","type":"uint256"},{"indexed":false,"name":"price","type":"uint256"},{"indexed":false,"name":"token","type":"address"},{"indexed":false,"name":"amountPaid","type":"uint256"}],"name":"LandQuadPurchased","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"metaTransactionProcessor","type":"address"},{"indexed":false,"name":"enabled","type":"bool"}],"name":"MetaTransactionProcessor","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"oldAdmin","type":"address"},{"indexed":false,"name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"}]

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

00000000000000000000000050f5474724e0ee42d9a4e711ccfb275809fd6d4a0000000000000000000000003845badade8e6dff049820680d1f14bd3903a5d00000000000000000000000003845badade8e6dff049820680d1f14bd3903a5d0000000000000000000000000eaa0993e1d21c2103e4f172a20d29371fbaf6d060000000000000000000000009695ed5020bb47880738db356678fe8cbc8ff60b32395e699ed85ea23474a5670dd7c2fd549a05db284aefd21e3583b1030068bf000000000000000000000000000000000000000000000000000000005dfb5830000000000000000000000000729d19f657bd0614b4985cf1d82531c67569197b0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f

-----Decoded View---------------
Arg [0] : landAddress (address): 0x50f5474724e0Ee42D9a4e711ccFB275809Fd6d4a
Arg [1] : sandContractAddress (address): 0x3845badAde8e6dFF049820680d1F14bD3903a5d0
Arg [2] : initialMetaTx (address): 0x3845badAde8e6dFF049820680d1F14bD3903a5d0
Arg [3] : admin (address): 0xEAA0993E1d21c2103e4f172a20D29371FbAF6D06
Arg [4] : initialWalletAddress (address): 0x9695ed5020BB47880738Db356678fe8cBc8FF60b
Arg [5] : merkleRoot (bytes32): 0x32395e699ed85ea23474a5670dd7c2fd549a05db284aefd21e3583b1030068bf
Arg [6] : expiryTime (uint256): 1576753200
Arg [7] : medianizerContractAddress (address): 0x729D19f657BD0614b4985Cf1D82531c67569197B
Arg [8] : daiTokenContractAddress (address): 0x6B175474E89094C44Da98b954EedeAC495271d0F

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 00000000000000000000000050f5474724e0ee42d9a4e711ccfb275809fd6d4a
Arg [1] : 0000000000000000000000003845badade8e6dff049820680d1f14bd3903a5d0
Arg [2] : 0000000000000000000000003845badade8e6dff049820680d1f14bd3903a5d0
Arg [3] : 000000000000000000000000eaa0993e1d21c2103e4f172a20d29371fbaf6d06
Arg [4] : 0000000000000000000000009695ed5020bb47880738db356678fe8cbc8ff60b
Arg [5] : 32395e699ed85ea23474a5670dd7c2fd549a05db284aefd21e3583b1030068bf
Arg [6] : 000000000000000000000000000000000000000000000000000000005dfb5830
Arg [7] : 000000000000000000000000729d19f657bd0614b4985cf1d82531c67569197b
Arg [8] : 0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f

455:10264:14:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8793:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;8793:91:14;;;:::i;:::-;;;;;;;;;;;;;;;;9025:88;;8:9:-1;5:2;;;30:1;27;20:12;5:2;9025:88:14;;;:::i;2459:160::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2459:160:14;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2459:160:14;;;;:::i;:::-;;2730:88;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2730:88:14;;;:::i;:::-;;;;;;;;;;;;;;;;;;3202:90;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3202:90:14;;;:::i;10263:192::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;10263:192:14;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;10263:192:14;;:::i;8010:656::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;8010:656:14;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;8010:656:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;8010:656:14;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;8010:656:14;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;-1:-1;8010:656:14;;-1:-1:-1;8010:656:14;-1:-1:-1;8010:656:14;:::i;264:82:0:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;264:82:0;;;:::i;:::-;;;;-1:-1:-1;;;;;264:82:0;;;;;;;;;;;;;;3417:163:14;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3417:163:14;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3417:163:14;;;;:::i;572:295:1:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;572:295:1;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;572:295:1;;;;;;;;;;:::i;469:197:0:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;469:197:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;469:197:0;-1:-1:-1;;;;;469:197:0;;:::i;3719:90:14:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3719:90:14;;;:::i;2079:269::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2079:269:14;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2079:269:14;-1:-1:-1;;;;;2079:269:14;;:::i;1330:131:1:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1330:131:1;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;1330:131:1;-1:-1:-1;;;;;1330:131:1;;:::i;5398:672:14:-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5398:672:14;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;5398:672:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;5398:672:14;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;5398:672:14;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;-1:-1;5398:672:14;;-1:-1:-1;5398:672:14;-1:-1:-1;5398:672:14;:::i;2929:162::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2929:162:14;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2929:162:14;;;;:::i;6631:818::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;6631:818:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;6631:818:14;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;6631:818:14;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;-1:-1;6631:818:14;;-1:-1:-1;6631:818:14;-1:-1:-1;6631:818:14;:::i;8793:91::-;8866:11;;8793:91;:::o;9025:88::-;9095:11;;9025:88;:::o;2459:160::-;2537:6;;-1:-1:-1;;;;;2537:6:14;2523:10;:20;2515:66;;;;-1:-1:-1;;;2515:66:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2591:11;:21;;;;;;;;;;;;;;;;;2459:160::o;2730:88::-;2800:11;;;;;;;;2730:88::o;3202:90::-;3272:13;;;;;;;;3202:90::o;10263:192::-;10336:7;10355:18;10376:15;:13;:15::i;:::-;10355:36;-1:-1:-1;10408:40:14;10355:36;10408:24;:10;678:17;10408:24;:14;:24;:::i;:::-;:28;:40;:28;:40;:::i;:::-;10401:47;10263:192;-1:-1:-1;;;10263:192:14:o;8010:656::-;8281:11;;;;;;;8273:48;;;;;-1:-1:-1;;;8273:48:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;8331:69;8346:5;8353:8;8363:1;8366;8369:4;8375:11;8388:4;8394:5;;8331:69;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;8331:14:14;;-1:-1:-1;;;8331:69:14:i;:::-;8411:19;8433:50;8463:19;8433:25;:11;678:17;8433:25;:15;:25;:::i;:50::-;8501:4;;8531:7;;8501:51;;;;;;8519:10;8501:51;;;;-1:-1:-1;;;;;8531:7:14;;;8501:51;;;;;;;;;;;;8411:72;;-1:-1:-1;8501:4:14;;;:17;;:51;;;;;;;;;;;;;;;:4;;:51;;;5:2:-1;;;;30:1;27;20:12;5:2;8501:51:14;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;8501:51:14;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;8501:51:14;8493:86;;;;;-1:-1:-1;;;8493:86:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;8590:69;8596:5;8603:2;8607:1;8610;8613:4;8619:11;8640:4;;;;;;;;;-1:-1:-1;;;;;8640:4:14;8647:11;8590:5;:69::i;:::-;8010:656;;;;;;;;;;;:::o;264:82:0:-;307:7;333:6;-1:-1:-1;;;;;333:6:0;264:82;:::o;3417:163:14:-;3496:6;;-1:-1:-1;;;;;3496:6:14;3482:10;:20;3474:67;;;;-1:-1:-1;;;3474:67:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3551:12;:22;;-1:-1:-1;;3551:22:14;;;;;;;;;;3417:163::o;572:295:1:-;709:6;;-1:-1:-1;;;;;709:6:1;695:10;:20;674:113;;;;-1:-1:-1;;;674:113:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;797:63;826:24;852:7;797:28;:63::i;:::-;572:295;;:::o;469:197:0:-;549:6;;-1:-1:-1;;;;;549:6:0;535:10;:20;527:60;;;;;-1:-1:-1;;;527:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;615:6;;602:30;;;-1:-1:-1;;;;;615:6:0;;;602:30;;;;;;;;;;;;;;;;;;;;;642:6;:17;;;;-1:-1:-1;;;;;642:17:0;;;;;;;;;;469:197::o;3719:90:14:-;3790:12;;;;3719:90;:::o;2079:269::-;-1:-1:-1;;;;;2160:23:14;;2152:75;;;;-1:-1:-1;;;2152:75:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2259:6;;-1:-1:-1;;;;;2259:6:14;2245:10;:20;2237:75;;;;-1:-1:-1;;;2237:75:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2322:7;:19;;;;-1:-1:-1;;;;;2322:19:14;;;;;;;;;;2079:269::o;1330:131:1:-;-1:-1:-1;;;;;1424:30:1;1401:4;1424:30;;;:25;:30;;;;;;;;;1330:131::o;5398:672:14:-;5670:12;;;;5662:50;;;;;-1:-1:-1;;;5662:50:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;5722:69;5737:5;5744:8;5754:1;5757;5760:4;5766:11;5779:4;5785:5;;5722:69;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;5722:14:14;;-1:-1:-1;;;5722:69:14:i;:::-;5822:5;;5881:7;;5822:109;;;;;;-1:-1:-1;;;;;5822:109:14;;;;;;;5881:7;;;5822:109;;;;;;;;;;;;:5;;;;;:18;;:109;;;;;;;;;;;;;;:5;;:109;;;5:2:-1;;;;30:1;27;20:12;5:2;5822:109:14;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;5822:109:14;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;5822:109:14;5801:182;;;;;-1:-1:-1;;;5801:182:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;5993:70;5999:5;6006:2;6010:1;6013;6016:4;6022:11;6043:5;;;;;;;;;-1:-1:-1;;;;;6043:5:14;6051:11;5993:5;:70::i;:::-;5398:672;;;;;;;;;;:::o;2929:162::-;3007:6;;-1:-1:-1;;;;;3007:6:14;2993:10;:20;2985:66;;;;-1:-1:-1;;;2985:66:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3061:13;:23;;;;;;;;;;;;;;;;;2929:162::o;6631:818::-;6910:13;;;;;;;6902:52;;;;;-1:-1:-1;;;6902:52:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;6964:69;6979:5;6986:8;6996:1;6999;7002:4;7008:11;7021:4;7027:5;;6964:69;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;6964:14:14;;-1:-1:-1;;;6964:69:14:i;:::-;7044:19;7066:35;7089:11;7066:22;:35::i;:::-;7044:57;;7132:11;7119:9;:24;;7111:58;;;;;-1:-1:-1;;;7111:58:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;7198:9;:23;;;7234:12;;7231:87;;7262:29;;:10;;:29;;;;;7282:8;;7262:29;;;;7282:8;7262:10;:29;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;7262:29:14;7231:87;7335:7;;7327:38;;-1:-1:-1;;;;;7335:7:14;;;;7327:38;;;;;7353:11;;7335:7;7327:38;7335:7;7327:38;7353:11;7335:7;7327:38;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;7327:38:14;7376:66;7382:5;7389:2;7393:1;7396;7399:4;7405:11;7426:1;7430:11;7376:5;:66::i;:::-;6631:818;;;;;;;;;;;;:::o;10580:137::-;10662:11;;;:18;;;;;;;;10628:7;;;;-1:-1:-1;;;;;10662:11:14;;:16;;:18;;;;;;;;;;;:11;:18;;;5:2:-1;;;;30:1;27;20:12;5:2;10662:18:14;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;10662:18:14;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;10662:18:14;;-1:-1:-1;;10580:137:14;:::o;211:426:10:-;269:9;511:6;507:45;;-1:-1:-1;540:1:10;533:8;;507:45;-1:-1:-1;566:5:10;;;570:1;566;:5;:1;589:5;;;;;:10;581:31;;;;;-1:-1:-1;;;581:31:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;211:426;;;;:::o;727:290::-;785:7;1009:1;1005;:5;;;;;;;727:290;-1:-1:-1;;;727:290:10:o;3815:729:14:-;4146:11;;4128:15;:29;4120:54;;;;;-1:-1:-1;;;4120:54:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;4192:19:14;;4201:10;4192:19;;:60;;-1:-1:-1;4241:10:14;4215:37;;;;:25;:37;;;;;;;;4192:60;4184:87;;;;;-1:-1:-1;;;4184:87:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;4289:22:14;;;;:43;;;4327:5;-1:-1:-1;;;;;4315:17:14;:8;-1:-1:-1;;;;;4315:17:14;;4289:43;4281:80;;;;;-1:-1:-1;;;4281:80:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;4371:12;4386:52;4404:1;4407;4410:4;4416:5;4423:8;4433:4;4386:17;:52::i;:::-;4371:67;;4470:20;4478:5;4485:4;4470:7;:20::i;:::-;4449:88;;;;;-1:-1:-1;;;4449:88:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;3815:729;;;;;;;;;:::o;4550:286::-;4698:5;;:34;;;;;;-1:-1:-1;;;;;4698:34:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:5;:34;;;;;;;;:5;;;:14;;:34;;;;;:5;;:34;;;;;;:5;;:34;;;5:2:-1;;;;30:1;27;20:12;5:2;4698:34:14;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;4747:82:14;;;;;;;;;;;;-1:-1:-1;;;;;4747:82:14;;;;;;;;;;;;;;;601:3;4781:13;;4776:19;;;-1:-1:-1;4747:82:14;;;;-1:-1:-1;4747:82:14;;;;;;;;;;;;;4550:286;;;;;;;;:::o;873:247:1:-;-1:-1:-1;;;;;978:51:1;;;;;;:25;:51;;;;;;;;;:61;;-1:-1:-1;;978:61:1;;;;;;;;;;1054:59;;;;;;;;;;;;;;;;;;;;;873:247;;:::o;9119:428:14:-;9369:161;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;9369:161:14;;;;;;;9346:194;;;;;;9119:428::o;9553:541::-;9631:4;9670;9631;9685:358;9709:5;:12;9705:1;:16;9685:358;;;9742:20;9765:5;9771:1;9765:8;;;;;;;;;;;;;;9742:31;;9807:12;9792;:27;9788:245;;;9881:12;9895;9864:44;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;9864:44:14;;;9854:55;;;;;;9839:70;;9788:245;;;9990:12;10004;9973:44;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;9973:44:14;;;9963:55;;;;;;9948:70;;9788:245;-1:-1:-1;9723:3:14;;9685:358;;;-1:-1:-1;10076:11:14;;10060:27;;9553:541;-1:-1:-1;;;9553:541:14:o

bzzr://f21bf72314851e6d6bf1061cc780efdf014b0750921f6a9ffe279147ad52246a