Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Ownable
•    - function setOwner(address _owner)
•  contract StorageUnit
•    - function write(bytes32 _key, bytes32 ...
•    - function read(bytes32 _key)
• library IsContract
•    - function isContract(address _addr)
• library DistributedStorage
•    - function contractSlot(bytes32 _struct ...
•    - function deploy(bytes32 _struct)
•    - function write(
•    - function read(
• library SafeMath
•    - function add(uint256 x, uint256 y)
•    - function sub(uint256 x, uint256 y)
•    - function mult(uint256 x, uint256 y)
•    - function div(uint256 x, uint256 y)
•    - function divRound(uint256 x, uint256 ...
• library Math
•    - function orderOfMagnitude(uint256 inp ...
•    - function min(uint256 _a, uint256 _b)
•    - function max(uint256 _a, uint256 _b)
•  contract GasPump
• interface IERC20
•    - function transfer(address _to, uint _ ...
•    - function transferFrom(address _from, ...
•    - function allowance(address _owner, ad ...
•    - function approve(address _spender, ui ...
•    - function balanceOf(address _owner)
• library AddressMinHeap
•    - function initialize(Heap storage _hea ...
•    - function encode(address _addr, uint25 ...
•    - function decode(uint256 _entry)
•    - function decodeAddress(uint256 _entry ...
•    - function top(Heap storage _heap)
•    - function has(Heap storage _heap, addr ...
•    - function size(Heap storage _heap)
•    - function entry(Heap storage _heap, ui ...
•    - function popTop(Heap storage _heap)
•    - function insert(Heap storage _heap, a ...
•    - function update(Heap storage _heap, a ...
•    - function bubbleUp(Heap storage _heap, ...
•    - function bubbleDown(Heap storage _hea ...
•  contract Heap is Ownable *
•    - function topSize()
•    - function addressAt(uint256 _i)
•    - function indexOf(address _addr)
•    - function entry(uint256 _i)
•    - function top()
•    - function size()
•    - function update(address _addr, uint25 ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2019-08-29
*/

/**
    AMGO token is based on the original work of Shuffle Monster token https://shuffle.monster/ (0x3A9FfF453d50D4Ac52A6890647b823379ba36B9E)
*/

pragma solidity ^0.5.10;

// File: contracts/commons/Ownable.sol


contract Ownable {
    address public owner;

    event TransferOwnership(address _from, address _to);

    constructor() public {
        owner = msg.sender;
        emit TransferOwnership(address(0), msg.sender);
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "only owner");
        _;
    }

    function setOwner(address _owner) external onlyOwner {
        emit TransferOwnership(owner, _owner);
        owner = _owner;
    }
}

// File: contracts/commons/StorageUnit.sol

pragma solidity ^0.5.10;


contract StorageUnit {
    address private owner;
    mapping(bytes32 => bytes32) private store;

    constructor() public {
        owner = msg.sender;
    }

    function write(bytes32 _key, bytes32 _value) external {
        /* solium-disable-next-line */
        require(msg.sender == owner);
        store[_key] = _value;
    }

    function read(bytes32 _key) external view returns (bytes32) {
        return store[_key];
    }
}

// File: contracts/utils/IsContract.sol

pragma solidity ^0.5.10;


library IsContract {
    function isContract(address _addr) internal view returns (bool) {
        bytes32 codehash;
        /* solium-disable-next-line */
        assembly { codehash := extcodehash(_addr) }
        return codehash != bytes32(0) && codehash != bytes32(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470);
    }
}

// File: contracts/utils/DistributedStorage.sol

pragma solidity ^0.5.10;




library DistributedStorage {
    function contractSlot(bytes32 _struct) private view returns (address) {
        return address(
            uint256(
                keccak256(
                    abi.encodePacked(
                        byte(0xff),
                        address(this),
                        _struct,
                        keccak256(type(StorageUnit).creationCode)
                    )
                )
            )
        );
    }

    function deploy(bytes32 _struct) private {
        bytes memory slotcode = type(StorageUnit).creationCode;
        /* solium-disable-next-line */
        assembly{ pop(create2(0, add(slotcode, 0x20), mload(slotcode), _struct)) }
    }

    function write(
        bytes32 _struct,
        bytes32 _key,
        bytes32 _value
    ) internal {
        StorageUnit store = StorageUnit(contractSlot(_struct));
        if (!IsContract.isContract(address(store))) {
            deploy(_struct);
        }

        /* solium-disable-next-line */
        (bool success, ) = address(store).call(
            abi.encodeWithSelector(
                store.write.selector,
                _key,
                _value
            )
        );

        require(success, "error writing storage");
    }

    function read(
        bytes32 _struct,
        bytes32 _key
    ) internal view returns (bytes32) {
        StorageUnit store = StorageUnit(contractSlot(_struct));
        if (!IsContract.isContract(address(store))) {
            return bytes32(0);
        }

        /* solium-disable-next-line */
        (bool success, bytes memory data) = address(store).staticcall(
            abi.encodeWithSelector(
                store.read.selector,
                _key
            )
        );

        require(success, "error reading storage");
        return abi.decode(data, (bytes32));
    }
}

// File: contracts/utils/SafeMath.sol

pragma solidity ^0.5.10;


library SafeMath {
    function add(uint256 x, uint256 y) internal pure returns (uint256) {
        uint256 z = x + y;
        require(z >= x, "Add overflow");
        return z;
    }

    function sub(uint256 x, uint256 y) internal pure returns (uint256) {
        require(x >= y, "Sub underflow");
        return x - y;
    }

    function mult(uint256 x, uint256 y) internal pure returns (uint256) {
        if (x == 0) {
            return 0;
        }

        uint256 z = x * y;
        require(z / x == y, "Mult overflow");
        return z;
    }

    function div(uint256 x, uint256 y) internal pure returns (uint256) {
        require(y != 0, "Div by zero");
        return x / y;
    }

    function divRound(uint256 x, uint256 y) internal pure returns (uint256) {
        require(y != 0, "Div by zero");
        uint256 r = x / y;
        if (x % y != 0) {
            r = r + 1;
        }

        return r;
    }
}

// File: contracts/utils/Math.sol

pragma solidity ^0.5.10;


library Math {
    function orderOfMagnitude(uint256 input) internal pure returns (uint256){
        uint256 counter = uint(-1);
        uint256 temp = input;

        do {
            temp /= 10;
            counter++;
        } while (temp != 0);

        return counter;
    }

    function min(uint256 _a, uint256 _b) internal pure returns (uint256) {
        if (_a < _b) {
            return _a;
        } else {
            return _b;
        }
    }

    function max(uint256 _a, uint256 _b) internal pure returns (uint256) {
        if (_a > _b) {
            return _a;
        } else {
            return _b;
        }
    }
}

// File: contracts/utils/GasPump.sol

pragma solidity ^0.5.10;


contract GasPump {
    bytes32 private stub;

    modifier requestGas(uint256 _factor) {
        if (tx.gasprice == 0 || gasleft() > block.gaslimit) {
            uint256 startgas = gasleft();
            _;
            uint256 delta = startgas - gasleft();
            uint256 target = (delta * _factor) / 100;
            startgas = gasleft();
            while (startgas - gasleft() < target) {
                // Burn gas
                stub = keccak256(abi.encodePacked(stub));
            }
        } else {
            _;
        }
    }
}

// File: contracts/interfaces/IERC20.sol

pragma solidity ^0.5.10;


interface IERC20 {
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    function transfer(address _to, uint _value) external returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
    function allowance(address _owner, address _spender) external view returns (uint256 remaining);
    function approve(address _spender, uint256 _value) external returns (bool success);
    function balanceOf(address _owner) external view returns (uint256 balance);
}

// File: contracts/commons/AddressMinHeap.sol

pragma solidity ^0.5.10;

/*
    @author Agustin Aguilar <[email protected]>
*/


library AddressMinHeap {
    using AddressMinHeap for AddressMinHeap.Heap;

    struct Heap {
        uint256[] entries;
        mapping(address => uint256) index;
    }

    function initialize(Heap storage _heap) internal {
        require(_heap.entries.length == 0, "already initialized");
        _heap.entries.push(0);
    }

    function encode(address _addr, uint256 _value) internal pure returns (uint256 _entry) {
        /* solium-disable-next-line */
        assembly {
            _entry := not(or(and(0xffffffffffffffffffffffffffffffffffffffff, _addr), shl(160, _value)))
        }
    }

    function decode(uint256 _entry) internal pure returns (address _addr, uint256 _value) {
        /* solium-disable-next-line */
        assembly {
            let entry := not(_entry)
            _addr := and(entry, 0xffffffffffffffffffffffffffffffffffffffff)
            _value := shr(160, entry)
        }
    }

    function decodeAddress(uint256 _entry) internal pure returns (address _addr) {
        /* solium-disable-next-line */
        assembly {
            _addr := and(not(_entry), 0xffffffffffffffffffffffffffffffffffffffff)
        }
    }

    function top(Heap storage _heap) internal view returns(address, uint256) {
        if (_heap.entries.length < 2) {
            return (address(0), 0);
        }

        return decode(_heap.entries[1]);
    }

    function has(Heap storage _heap, address _addr) internal view returns (bool) {
        return _heap.index[_addr] != 0;
    }

    function size(Heap storage _heap) internal view returns (uint256) {
        return _heap.entries.length - 1;
    }

    function entry(Heap storage _heap, uint256 _i) internal view returns (address, uint256) {
        return decode(_heap.entries[_i + 1]);
    }

    // RemoveMax pops off the root element of the heap (the highest value here) and rebalances the heap
    function popTop(Heap storage _heap) internal returns(address _addr, uint256 _value) {
        // Ensure the heap exists
        uint256 heapLength = _heap.entries.length;
        require(heapLength > 1, "The heap does not exists");

        // take the root value of the heap
        (_addr, _value) = decode(_heap.entries[1]);
        _heap.index[_addr] = 0;

        if (heapLength == 2) {
            _heap.entries.length = 1;
        } else {
            // Takes the last element of the array and put it at the root
            uint256 val = _heap.entries[heapLength - 1];
            _heap.entries[1] = val;

            // Delete the last element from the array
            _heap.entries.length = heapLength - 1;

            // Start at the top
            uint256 ind = 1;

            // Bubble down
            ind = _heap.bubbleDown(ind, val);

            // Update index
            _heap.index[decodeAddress(val)] = ind;
        }
    }

    // Inserts adds in a value to our heap.
    function insert(Heap storage _heap, address _addr, uint256 _value) internal {
        require(_heap.index[_addr] == 0, "The entry already exists");

        // Add the value to the end of our array
        uint256 encoded = encode(_addr, _value);
        _heap.entries.push(encoded);

        // Start at the end of the array
        uint256 currentIndex = _heap.entries.length - 1;

        // Bubble Up
        currentIndex = _heap.bubbleUp(currentIndex, encoded);

        // Update index
        _heap.index[_addr] = currentIndex;
    }

    function update(Heap storage _heap, address _addr, uint256 _value) internal {
        uint256 ind = _heap.index[_addr];
        require(ind != 0, "The entry does not exists");

        uint256 can = encode(_addr, _value);
        uint256 val = _heap.entries[ind];
        uint256 newInd;

        if (can < val) {
            // Bubble down
            newInd = _heap.bubbleDown(ind, can);
        } else if (can > val) {
            // Bubble up
            newInd = _heap.bubbleUp(ind, can);
        } else {
            // no changes needed
            return;
        }

        // Update entry
        _heap.entries[newInd] = can;

        // Update index
        if (newInd != ind) {
            _heap.index[_addr] = newInd;
        }
    }

    function bubbleUp(Heap storage _heap, uint256 _ind, uint256 _val) internal returns (uint256 ind) {
        // Bubble up
        ind = _ind;
        if (ind != 1) {
            uint256 parent = _heap.entries[ind / 2];
            while (parent < _val) {
                // If the parent value is lower than our current value, we swap them
                (_heap.entries[ind / 2], _heap.entries[ind]) = (_val, parent);

                // Update moved Index
                _heap.index[decodeAddress(parent)] = ind;

                // change our current Index to go up to the parent
                ind = ind / 2;
                if (ind == 1) {
                    break;
                }

                // Update parent
                parent = _heap.entries[ind / 2];
            }
        }
    }

    function bubbleDown(Heap storage _heap, uint256 _ind, uint256 _val) internal returns (uint256 ind) {
        // Bubble down
        ind = _ind;

        uint256 lenght = _heap.entries.length;
        uint256 target = lenght - 1;

        while (ind * 2 < lenght) {
            // get the current index of the children
            uint256 j = ind * 2;

            // left child value
            uint256 leftChild = _heap.entries[j];

            // Store the value of the child
            uint256 childValue;

            if (target > j) {
                // The parent has two childs 👨‍👧‍👦

                // Load right child value
                uint256 rightChild = _heap.entries[j + 1];

                // Compare the left and right child.
                // if the rightChild is greater, then point j to it's index
                // and save the value
                if (leftChild < rightChild) {
                    childValue = rightChild;
                    j = j + 1;
                } else {
                    // The left child is greater
                    childValue = leftChild;
                }
            } else {
                // The parent has a single child 👨‍👦
                childValue = leftChild;
            }

            // Check if the child has a lower value
            if (_val > childValue) {
                break;
            }

            // else swap the value
            (_heap.entries[ind], _heap.entries[j]) = (childValue, _val);

            // Update moved Index
            _heap.index[decodeAddress(childValue)] = ind;

            // and let's keep going down the heap
            ind = j;
        }
    }
}

// File: contracts/Heap.sol

pragma solidity ^0.5.10;



contract Heap is Ownable {
    using AddressMinHeap for AddressMinHeap.Heap;

    // heap
    AddressMinHeap.Heap private heap;

    // Heap events
    event JoinHeap(address indexed _address, uint256 _balance, uint256 _prevSize);
    event LeaveHeap(address indexed _address, uint256 _balance, uint256 _prevSize);

    uint256 public constant TOP_SIZE = 212;

    constructor() public {
        heap.initialize();
    }

    function topSize() external pure returns (uint256) {
        return TOP_SIZE;
    }

    function addressAt(uint256 _i) external view returns (address addr) {
        (addr, ) = heap.entry(_i);
    }

    function indexOf(address _addr) external view returns (uint256) {
        return heap.index[_addr];
    }

    function entry(uint256 _i) external view returns (address, uint256) {
        return heap.entry(_i);
    }

    function top() external view returns (address, uint256) {
        return heap.top();
    }

    function size() external view returns (uint256) {
        return heap.size();
    }

    function update(address _addr, uint256 _new) external onlyOwner {
        uint256 _size = heap.size();

        // If the heap is empty
        // join the _addr
        if (_size == 0) {
            emit JoinHeap(_addr, _new, 0);
            heap.insert(_addr, _new);
            return;
        }

        // Load top value of the heap
        (, uint256 lastBal) = heap.top();

        // If our target address already is in the heap
        if (heap.has(_addr)) {
            // Update the target address value
            heap.update(_addr, _new);
            // If the new value is 0
            // always pop the heap
            // we updated the heap, so our address should be on top
            if (_new == 0) {
                heap.popTop();
                emit LeaveHeap(_addr, 0, _size);
            }
        } else {
            // IF heap is full or new balance is higher than pop heap
            if (_new != 0 && (_size < TOP_SIZE || lastBal < _new)) {
                // If heap is full pop heap
                if (_size >= TOP_SIZE) {
                    (address _poped, uint256 _balance) = heap.popTop();
                    emit LeaveHeap(_poped, _balance, _size);
                }

                // Insert new value
                heap.insert(_addr, _new);
                emit JoinHeap(_addr, _new, _size);
            }
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[{"name":"_i","type":"uint256"}],"name":"addressAt","outputs":[{"name":"addr","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_owner","type":"address"}],"name":"setOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"TOP_SIZE","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"topSize","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"size","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_addr","type":"address"},{"name":"_new","type":"uint256"}],"name":"update","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_i","type":"uint256"}],"name":"entry","outputs":[{"name":"","type":"address"},{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_addr","type":"address"}],"name":"indexOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"top","outputs":[{"name":"","type":"address"},{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_address","type":"address"},{"indexed":false,"name":"_balance","type":"uint256"},{"indexed":false,"name":"_prevSize","type":"uint256"}],"name":"JoinHeap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_address","type":"address"},{"indexed":false,"name":"_balance","type":"uint256"},{"indexed":false,"name":"_prevSize","type":"uint256"}],"name":"LeaveHeap","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_from","type":"address"},{"indexed":false,"name":"_to","type":"address"}],"name":"TransferOwnership","type":"event"}]

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

13898:2488:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;13898:2488:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14433:112;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;14433:112:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;562:134;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;562:134:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;14228:38;;;:::i;:::-;;;;;;;;;;;;;;;;;;;14340:85;;;:::i;:::-;;;;;;;;;;;;;;;;;;;248:20;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;14884:85;;;:::i;:::-;;;;;;;;;;;;;;;;;;;14977:1406;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;14977:1406:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;14668:108;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;14668:108:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14553:107;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;14553:107:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;14784:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14433:112;14487:12;14523:14;14534:2;14523:4;:10;;:14;;;;:::i;:::-;14512:25;;;;;14433:112;;;:::o;562:134::-;514:5;;;;;;;;;;;500:19;;:10;:19;;;492:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;631:32;649:5;;;;;;;;;;;656:6;631:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;682:6;674:5;;:14;;;;;;;;;;;;;;;;;;562:134;:::o;14228:38::-;14263:3;14228:38;:::o;14340:85::-;14382:7;14263:3;14402:15;;14340:85;:::o;248:20::-;;;;;;;;;;;;;:::o;14884:85::-;14923:7;14950:11;:4;:9;:11::i;:::-;14943:18;;14884:85;:::o;14977:1406::-;514:5;;;;;;;;;;;500:19;;:10;:19;;;492:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15052:13;15068:11;:4;:9;:11::i;:::-;15052:27;;15165:1;15156:5;:10;15152:132;;;15197:5;15188:24;;;15204:4;15210:1;15188:24;;;;;;;;;;;;;;;;;;;;;;;;15227;15239:5;15246:4;15227;:11;;:24;;;;;:::i;:::-;15266:7;;;15152:132;15338:15;15357:10;:4;:8;:10::i;:::-;15335:32;;;15441:15;15450:5;15441:4;:8;;:15;;;;:::i;:::-;15437:939;;;15521:24;15533:5;15540:4;15521;:11;;:24;;;;;:::i;:::-;15715:1;15707:4;:9;15703:113;;;15737:13;:4;:11;:13::i;:::-;;;15784:5;15774:26;;;15791:1;15794:5;15774:26;;;;;;;;;;;;;;;;;;;;;;;;15703:113;15437:939;;;15931:1;15923:4;:9;;:49;;;;;14263:3;15937:5;:16;:34;;;;15967:4;15957:7;:14;15937:34;15923:49;15919:446;;;14263:3;16042:5;:17;16038:178;;16085:14;16101:16;16121:13;:4;:11;:13::i;:::-;16084:50;;;;16172:6;16162:34;;;16180:8;16190:5;16162:34;;;;;;;;;;;;;;;;;;;;;;;;16038:178;;;16273:24;16285:5;16292:4;16273;:11;;:24;;;;;:::i;:::-;16330:5;16321:28;;;16337:4;16343:5;16321:28;;;;;;;;;;;;;;;;;;;;;;;;15919:446;15437:939;545:1;;;14977:1406;;:::o;14668:108::-;14718:7;14727;14754:14;14765:2;14754:4;:10;;:14;;;;:::i;:::-;14747:21;;;;14668:108;;;:::o;14553:107::-;14608:7;14635:4;:10;;:17;14646:5;14635:17;;;;;;;;;;;;;;;;14628:24;;14553:107;;;:::o;14784:92::-;14822:7;14831;14858:10;:4;:8;:10::i;:::-;14851:17;;;;14784:92;;:::o;8627:143::-;8697:7;8706;8733:29;8740:5;:13;;8759:1;8754:2;:6;8740:21;;;;;;;;;;;;;;;;8733:6;:29::i;:::-;8726:36;;;;8627:143;;;;;:::o;8503:116::-;8560:7;8610:1;8587:5;:13;;:20;;;;:24;8580:31;;8503:116;;;:::o;9915:555::-;10032:1;10010:5;:11;;:18;10022:5;10010:18;;;;;;;;;;;;;;;;:23;10002:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10125:15;10143:21;10150:5;10157:6;10143;:21::i;:::-;10125:39;;10175:5;:13;;10194:7;10175:27;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;10175:27:0;;;;;;;;;;;;;;;;;;;;;;10257:20;10303:1;10280:5;:13;;:20;;;;:24;10257:47;;10354:37;10369:12;10383:7;10354:5;:14;;:37;;;;;:::i;:::-;10339:52;;10450:12;10429:5;:11;;:18;10441:5;10429:18;;;;;;;;;;;;;;;:33;;;;9915:555;;;;;:::o;8147:214::-;8202:7;8211;8258:1;8235:5;:13;;:20;;;;:24;8231:79;;;8292:1;8296;8276:22;;;;;;;;;;;;8231:79;8329:24;8336:5;:13;;8350:1;8336:16;;;;;;;;;;;;;;;;8329:6;:24::i;:::-;8322:31;;;;8147:214;;;;:::o;8369:126::-;8440:4;8486:1;8464:5;:11;;:18;8476:5;8464:18;;;;;;;;;;;;;;;;:23;;8457:30;;8369:126;;;;:::o;10478:772::-;10565:11;10579:5;:11;;:18;10591:5;10579:18;;;;;;;;;;;;;;;;10565:32;;10623:1;10616:3;:8;;10608:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10667:11;10681:21;10688:5;10695:6;10681;:21::i;:::-;10667:35;;10713:11;10727:5;:13;;10741:3;10727:18;;;;;;;;;;;;;;;;10713:32;;10756:14;10793:3;10787;:9;10783:285;;;10850:26;10867:3;10872;10850:5;:16;;:26;;;;;:::i;:::-;10841:35;;10783:285;;;10904:3;10898;:9;10894:174;;;10959:24;10974:3;10979;10959:5;:14;;:24;;;;;:::i;:::-;10950:33;;10894:174;;;11050:7;;;;;;10894:174;10783:285;11129:3;11105:5;:13;;11119:6;11105:21;;;;;;;;;;;;;;;:27;;;;11184:3;11174:6;:13;11170:73;;11225:6;11204:5;:11;;:18;11216:5;11204:18;;;;;;;;;;;;;;;:27;;;;11170:73;10478:772;;;;;;;;:::o;8883:979::-;8936:13;8951:14;9013:18;9034:5;:13;;:20;;;;9013:41;;9086:1;9073:10;:14;9065:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9191:24;9198:5;:13;;9212:1;9198:16;;;;;;;;;;;;;;;;9191:6;:24::i;:::-;9173:42;;;;;;;;9247:1;9226:5;:11;;:18;9238:5;9226:18;;;;;;;;;;;;;;;:22;;;;9279:1;9265:10;:15;9261:594;;;9320:1;9297:5;:13;;:24;;;;;:::i;:::-;;9261:594;;;9429:11;9443:5;:13;;9470:1;9457:10;:14;9443:29;;;;;;;;;;;;;;;;9429:43;;9506:3;9487:5;:13;;9501:1;9487:16;;;;;;;;;;;;;;;:22;;;;9617:1;9604:10;:14;9581:5;:13;;:37;;;;;:::i;:::-;;9668:11;9682:1;9668:15;;9734:26;9751:3;9756;9734:5;:16;;:26;;;;;:::i;:::-;9728:32;;9840:3;9806:5;:11;;:31;9818:18;9832:3;9818:13;:18::i;:::-;9806:31;;;;;;;;;;;;;;;:37;;;;9261:594;;;8883:979;;;;:::o;7573:319::-;7628:13;7643:14;7751:6;7747:11;7792:42;7785:5;7781:54;7772:63;;7868:5;7863:3;7859:15;7849:25;;7719:166;;;;:::o;7295:270::-;7365:14;7538:6;7533:3;7529:16;7521:5;7477:42;7473:54;7470:76;7466:81;7456:91;;7441:117;;;;:::o;11258:824::-;11342:11;11394:4;11388:10;;11420:1;11413:3;:8;11409:666;;11438:14;11455:5;:13;;11475:1;11469:3;:7;;;;;;11455:22;;;;;;;;;;;;;;;;11438:39;;11492:572;11508:4;11499:6;:13;11492:572;;;11667:4;11673:6;11620:5;:13;;11640:1;11634:3;:7;;;;;;11620:22;;;;;;;;;;;;;;;;11644:5;:13;;11658:3;11644:18;;;;;;;;;;;;;;;;11619:61;;;;;;;;;;;;11777:3;11740:5;:11;;:34;11752:21;11766:6;11752:13;:21::i;:::-;11740:34;;;;;;;;;;;;;;;:40;;;;11881:1;11875:3;:7;;;;;;11869:13;;11912:1;11905:3;:8;11901:62;;;11938:5;;11901:62;12026:5;:13;;12046:1;12040:3;:7;;;;;;12026:22;;;;;;;;;;;;;;;;12017:31;;11492:572;;;11409:666;;11258:824;;;;;:::o;12090:1738::-;12176:11;12230:4;12224:10;;12247:14;12264:5;:13;;:20;;;;12247:37;;12295:14;12321:1;12312:6;:10;12295:27;;12335:1486;12352:6;12348:1;12342:3;:7;:16;12335:1486;;;12429:9;12447:1;12441:3;:7;12429:19;;12498:17;12518:5;:13;;12532:1;12518:16;;;;;;;;;;;;;;;;12498:36;;12596:18;12644:1;12635:6;:10;12631:764;;;12776:18;12797:5;:13;;12815:1;12811;:5;12797:20;;;;;;;;;;;;;;;;12776:41;;13024:10;13012:9;:22;13008:247;;;13072:10;13059:23;;13113:1;13109;:5;13105:9;;13008:247;;;13226:9;13213:22;;13008:247;12631:764;;;;13370:9;13357:22;;12631:764;13475:10;13468:4;:17;13464:63;;;13506:5;;;;;13464:63;13621:10;13633:4;13580:5;:13;;13594:3;13580:18;;;;;;;;;;;;;;;;13600:5;:13;;13614:1;13600:16;;;;;;;;;;;;;;;;13579:59;;;;;;;;;;;;13731:3;13690:5;:11;;:38;13702:25;13716:10;13702:13;:25::i;:::-;13690:38;;;;;;;;;;;;;;;:44;;;;13808:1;13802:7;;12335:1486;;;;;;12090:1738;;;;;;;:::o;7900:239::-;7962:13;8078:42;8069:6;8065:11;8061:60;8052:69;;8037:95;;;:::o;13898:2488::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;7130:157::-;7222:1;7198:5;:13;;:20;;;;:25;7190:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7258:5;:13;;7277:1;7258:21;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;7258:21:0;;;;;;;;;;;;;;;;;;;;;;7130:157;:::o

bzzr://5f3b1aa933a431458114cc9ca241b52693a381408525f81bfb520550f9f961de