Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function mul(uint256 _a, uint256 _b)
•    - function div(uint256 _a, uint256 _b)
•    - function sub(uint256 _a, uint256 _b)
•    - function add(uint256 _a, uint256 _b)
•    - function mod(uint256 a, uint256 b)
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•  contract ERC20
•    - function totalSupply()
•    - function balanceOf(address _who)
•    - function allowance(address _owner, ad ...
•    - function transfer(address _to, uint25 ...
•    - function approve(address _spender, ui ...
•    - function transferFrom(address _from, ...
•    - function decimals()
• library Utils
•    - function precision()
•    - function max_qty()
•    - function max_rate()
•    - function max_decimals()
•    - function eth_decimals()
•    - function max_uint()
•    - function eth_address()
•    - function getDecimals(address token)
• functionSigLength, // size of data
•    - function tokenAllowanceAndBalanceSet(
•    - function calcDstQty(uint srcQty, uint ...
•    - function calcSrcQty(uint dstQty, uint ...
•    - function calcDestAmount(ERC20 src, ER ...
•    - function calcSrcAmount(ERC20 src, ERC ...
•    - function calcRateFromQty(uint srcAmou ...
•    - function min(uint256 a, uint256 b)
• library ERC20SafeTransfer
•    - function safeTransfer(address _tokenA ...
•    - function safeTransferFrom(address _to ...
•    - function safeApprove(address _tokenAd ...
•    - function fetchReturnData()
•  contract AllowanceSetter
•    - function approveAddress(address addre ...
•  contract Ownable
•    - function renounceOwnership()
•    - function transferOwnership(address pa ...
•    - function _transferOwnership(address p ...
•  contract Withdrawable is Ownable
•    - function withdrawToken(address _token ...
•    - function withdrawETH(uint256 _amount)
•  contract Pausable is Ownable
•    - function paused()
•    - function pause()
•    - function unpause()
•  contract ExchangeHandler is Withdr ...
•    - function performOrder(
•  contract LibEIP712
•    - function hashEIP712Message(bytes32 ha ...
•  contract LibOrder is
•    - function getOrderHash(Order memory or ...
•    - function hashOrder(Order memory order ...
•  contract LibFillResults
•    - function addFillResults(FillResults m ...
•  contract IExchangeCore
•    - function fillOrder(
•    - function fillOrderNoThrow(
•    - function getOrderInfo(LibOrder.Order ...
•    - function getAssetProxy(bytes4 assetPr ...
•    - function isValidSignature(
•  contract TotleControl is Ownable
•    - function addTotle(
•    - function removeTotle(
• interface WETH
•    - function deposit()
•    - function withdraw(uint256 amount)
•  contract ZeroExExchangeHandler is ... *
•    - function getAmountToGive_(
•    - function getAssetDataAvailable(bytes ...
•    - function getZeroExOrder(OrderData mem ...
•    - function staticExchangeChecks(
•    - function performOrder(
•    - function getPartialAmount(
•    - function toAddress(bytes memory _byte ...
•    - function toBytes4(bytes memory _bytes ...
•    - function toUint(bytes memory _bytes, ...
•    - function()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2019-11-12
*/

pragma solidity 0.5.7;
pragma experimental ABIEncoderV2;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, reverts on overflow.
  */
  function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (_a == 0) {
      return 0;
    }

    uint256 c = _a * _b;
    require(c / _a == _b);

    return c;
  }

  /**
  * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
  */
  function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
    require(_b > 0); // Solidity only automatically asserts 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 c;
  }

  /**
  * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
    require(_b <= _a);
    uint256 c = _a - _b;

    return c;
  }

  /**
  * @dev Adds two numbers, reverts on overflow.
  */
  function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
    uint256 c = _a + _b;
    require(c >= _a);

    return c;
  }

  /**
  * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
  * reverts when dividing by zero.
  */
  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b != 0);
    return a % b;
  }
}

/**
 * @title Math
 * @dev Assorted math operations
 */

library Math {
  function max(uint256 a, uint256 b) internal pure returns (uint256) {
    return a >= b ? a : b;
  }

  function min(uint256 a, uint256 b) internal pure returns (uint256) {
    return a < b ? a : b;
  }

  function average(uint256 a, uint256 b) internal pure returns (uint256) {
    // (a + b) / 2 can overflow, so we distribute
    return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
  }
}

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 {
  function totalSupply() public view returns (uint256);

  function balanceOf(address _who) public view returns (uint256);

  function allowance(address _owner, address _spender)
    public view returns (uint256);

  function transfer(address _to, uint256 _value) public returns (bool);

  function approve(address _spender, uint256 _value)
    public returns (bool);

  function transferFrom(address _from, address _to, uint256 _value)
    public returns (bool);

  function decimals() public view returns (uint256);

  event Transfer(
    address indexed from,
    address indexed to,
    uint256 value
  );

  event Approval(
    address indexed owner,
    address indexed spender,
    uint256 value
  );
}

/*
    Modified Util contract as used by Kyber Network
*/

library Utils {

    uint256 constant internal PRECISION = (10**18);
    uint256 constant internal MAX_QTY   = (10**28); // 10B tokens
    uint256 constant internal MAX_RATE  = (PRECISION * 10**6); // up to 1M tokens per ETH
    uint256 constant internal MAX_DECIMALS = 18;
    uint256 constant internal ETH_DECIMALS = 18;
    uint256 constant internal MAX_UINT = 2**256-1;
    address constant internal ETH_ADDRESS = address(0x0);

    // Currently constants can't be accessed from other contracts, so providing functions to do that here
    function precision() internal pure returns (uint256) { return PRECISION; }
    function max_qty() internal pure returns (uint256) { return MAX_QTY; }
    function max_rate() internal pure returns (uint256) { return MAX_RATE; }
    function max_decimals() internal pure returns (uint256) { return MAX_DECIMALS; }
    function eth_decimals() internal pure returns (uint256) { return ETH_DECIMALS; }
    function max_uint() internal pure returns (uint256) { return MAX_UINT; }
    function eth_address() internal pure returns (address) { return ETH_ADDRESS; }

    /// @notice Retrieve the number of decimals used for a given ERC20 token
    /// @dev As decimals are an optional feature in ERC20, this contract uses `call` to
    /// ensure that an exception doesn't cause transaction failure
    /// @param token the token for which we should retrieve the decimals
    /// @return decimals the number of decimals in the given token
    function getDecimals(address token)
        internal
        returns (uint256 decimals)
    {
        bytes4 functionSig = bytes4(keccak256("decimals()"));

        /// @dev Using assembly due to issues with current solidity `address.call()`
        /// implementation: https://github.com/ethereum/solidity/issues/2884
        assembly {
            // Pointer to next free memory slot
            let ptr := mload(0x40)
            // Store functionSig variable at ptr
            mstore(ptr,functionSig)
            let functionSigLength := 0x04
            let wordLength := 0x20

            let success := call(
                                gas, // Amount of gas
                                token, // Address to call
                                0, // ether to send
                                ptr, // ptr to input data
                                functionSigLength, // size of data
                                ptr, // where to store output data (overwrite input)
                                wordLength // size of output data (32 bytes)
                               )

            switch success
            case 0 {
                decimals := 0 // If the token doesn't implement `decimals()`, return 0 as default
            }
            case 1 {
                decimals := mload(ptr) // Set decimals to return data from call
            }
            mstore(0x40,add(ptr,0x04)) // Reset the free memory pointer to the next known free location
        }
    }

    /// @dev Checks that a given address has its token allowance and balance set above the given amount
    /// @param tokenOwner the address which should have custody of the token
    /// @param tokenAddress the address of the token to check
    /// @param tokenAmount the amount of the token which should be set
    /// @param addressToAllow the address which should be allowed to transfer the token
    /// @return bool true if the allowance and balance is set, false if not
    function tokenAllowanceAndBalanceSet(
        address tokenOwner,
        address tokenAddress,
        uint256 tokenAmount,
        address addressToAllow
    )
        internal
        view
        returns (bool)
    {
        return (
            ERC20(tokenAddress).allowance(tokenOwner, addressToAllow) >= tokenAmount &&
            ERC20(tokenAddress).balanceOf(tokenOwner) >= tokenAmount
        );
    }

    function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns (uint) {
        if (dstDecimals >= srcDecimals) {
            require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
            return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
        } else {
            require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
            return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
        }
    }

    function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns (uint) {

        //source quantity is rounded up. to avoid dest quantity being too low.
        uint numerator;
        uint denominator;
        if (srcDecimals >= dstDecimals) {
            require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
            numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
            denominator = rate;
        } else {
            require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
            numerator = (PRECISION * dstQty);
            denominator = (rate * (10**(dstDecimals - srcDecimals)));
        }
        return (numerator + denominator - 1) / denominator; //avoid rounding down errors
    }

    function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal returns (uint) {
        return calcDstQty(srcAmount, getDecimals(address(src)), getDecimals(address(dest)), rate);
    }

    function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal returns (uint) {
        return calcSrcQty(destAmount, getDecimals(address(src)), getDecimals(address(dest)), rate);
    }

    function calcRateFromQty(uint srcAmount, uint destAmount, uint srcDecimals, uint dstDecimals)
        internal pure returns (uint)
    {
        require(srcAmount <= MAX_QTY);
        require(destAmount <= MAX_QTY);

        if (dstDecimals >= srcDecimals) {
            require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
            return (destAmount * PRECISION / ((10 ** (dstDecimals - srcDecimals)) * srcAmount));
        } else {
            require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
            return (destAmount * PRECISION * (10 ** (srcDecimals - dstDecimals)) / srcAmount);
        }
    }

    /// @notice Bringing this in from the Math library as we've run out of space in TotlePrimary (see EIP-170)
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}

library ERC20SafeTransfer {
    function safeTransfer(address _tokenAddress, address _to, uint256 _value) internal returns (bool success) {
        (success,) = _tokenAddress.call(abi.encodeWithSignature("transfer(address,uint256)", _to, _value));
        require(success, "Transfer failed");

        return fetchReturnData();
    }

    function safeTransferFrom(address _tokenAddress, address _from, address _to, uint256 _value) internal returns (bool success) {
        (success,) = _tokenAddress.call(abi.encodeWithSignature("transferFrom(address,address,uint256)", _from, _to, _value));
        require(success, "Transfer From failed");

        return fetchReturnData();
    }

    function safeApprove(address _tokenAddress, address _spender, uint256 _value) internal returns (bool success) {
        (success,) = _tokenAddress.call(abi.encodeWithSignature("approve(address,uint256)", _spender, _value));
        require(success,  "Approve failed");

        return fetchReturnData();
    }

    function fetchReturnData() internal pure returns (bool success){
        assembly {
            switch returndatasize()
            case 0 {
                success := 1
            }
            case 32 {
                returndatacopy(0, 0, 32)
                success := mload(0)
            }
            default {
                revert(0, 0)
            }
        }
    }

}

/// @title A contract which is used to check and set allowances of tokens
/// @dev In order to use this contract is must be inherited in the contract which is using
/// its functionality
contract AllowanceSetter {
    uint256 constant MAX_UINT = 2**256 - 1;

    /// @notice A function which allows the caller to approve the max amount of any given token
    /// @dev In order to function correctly, token allowances should not be set anywhere else in
    /// the inheriting contract
    /// @param addressToApprove the address which we want to approve to transfer the token
    /// @param token the token address which we want to call approve on
    function approveAddress(address addressToApprove, address token) internal {
        if(ERC20(token).allowance(address(this), addressToApprove) == 0) {
            require(ERC20SafeTransfer.safeApprove(token, addressToApprove, MAX_UINT));
        }
    }

}

/*
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address payable public owner;


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


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

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

  /**
   * @dev Allows the current owner to relinquish control of the contract.
   * @notice Renouncing to ownership will leave the contract without an owner.
   * It will not be possible to call the functions with the `onlyOwner`
   * modifier anymore.
   */
  function renounceOwnership() public onlyOwner {
    emit OwnershipRenounced(owner);
    owner = address(0);
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function transferOwnership(address payable _newOwner) public onlyOwner {
    _transferOwnership(_newOwner);
  }

  /**
   * @dev Transfers control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function _transferOwnership(address payable _newOwner) internal {
    require(_newOwner != address(0));
    emit OwnershipTransferred(owner, _newOwner);
    owner = _newOwner;
  }
}

/// @title A contract which allows its owner to withdraw any ether which is contained inside
contract Withdrawable is Ownable {

    /// @notice Withdraw ether contained in this contract and send it back to owner
    /// @dev onlyOwner modifier only allows the contract owner to run the code
    /// @param _token The address of the token that the user wants to withdraw
    /// @param _amount The amount of tokens that the caller wants to withdraw
    /// @return bool value indicating whether the transfer was successful
    function withdrawToken(address _token, uint256 _amount) external onlyOwner returns (bool) {
        return ERC20SafeTransfer.safeTransfer(_token, owner, _amount);
    }

    /// @notice Withdraw ether contained in this contract and send it back to owner
    /// @dev onlyOwner modifier only allows the contract owner to run the code
    /// @param _amount The amount of ether that the caller wants to withdraw
    function withdrawETH(uint256 _amount) external onlyOwner {
        owner.transfer(_amount);
    }
}

/**
 * @title Pausable
 * @dev Base contract which allows children to implement an emergency stop mechanism.
 */
contract Pausable is Ownable {
  event Paused();
  event Unpaused();

  bool private _paused = false;

  /**
   * @return true if the contract is paused, false otherwise.
   */
  function paused() public view returns (bool) {
    return _paused;
  }

  /**
   * @dev Modifier to make a function callable only when the contract is not paused.
   */
  modifier whenNotPaused() {
    require(!_paused, "Contract is paused.");
    _;
  }

  /**
   * @dev Modifier to make a function callable only when the contract is paused.
   */
  modifier whenPaused() {
    require(_paused, "Contract not paused.");
    _;
  }

  /**
   * @dev called by the owner to pause, triggers stopped state
   */
  function pause() public onlyOwner whenNotPaused {
    _paused = true;
    emit Paused();
  }

  /**
   * @dev called by the owner to unpause, returns to normal state
   */
  function unpause() public onlyOwner whenPaused {
    _paused = false;
    emit Unpaused();
  }
}

/// @title Interface for all exchange handler contracts
contract ExchangeHandler is Withdrawable, Pausable {

    /*
    *   State Variables
    */

    /* Logger public logger; */
    /*
    *   Modifiers
    */

    function performOrder(
        bytes memory genericPayload,
        uint256 availableToSpend,
        uint256 targetAmount,
        bool targetAmountIsSource
    )
        public
        payable
        returns (uint256 amountSpentOnOrder, uint256 amountReceivedFromOrder);

}

// File: contracts/exchange_handlers/interfaces/zeroex/LibEIP712.sol

/*

  Copyright 2018 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

contract LibEIP712 {

    // EIP191 header for EIP712 prefix
    string constant internal EIP191_HEADER = "\x19\x01";

    // EIP712 Domain Name value
    string constant internal EIP712_DOMAIN_NAME = "0x Protocol";

    // EIP712 Domain Version value
    string constant internal EIP712_DOMAIN_VERSION = "2";

    // Hash of the EIP712 Domain Separator Schema
    bytes32 constant internal EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = keccak256(abi.encodePacked(
        "EIP712Domain(",
        "string name,",
        "string version,",
        "address verifyingContract",
        ")"
    ));

    // Hash of the EIP712 Domain Separator data
    // solhint-disable-next-line var-name-mixedcase
    bytes32 public EIP712_DOMAIN_HASH;

    constructor ()
        public
    {
        EIP712_DOMAIN_HASH = keccak256(abi.encodePacked(
            EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
            keccak256(bytes(EIP712_DOMAIN_NAME)),
            keccak256(bytes(EIP712_DOMAIN_VERSION)),
            abi.encodePacked(address(this))
        ));
    }

    /// @dev Calculates EIP712 encoding for a hash struct in this EIP712 Domain.
    /// @param hashStruct The EIP712 hash struct.
    /// @return EIP712 hash applied to this EIP712 Domain.
    function hashEIP712Message(bytes32 hashStruct)
        internal
        view
        returns (bytes32 result)
    {
        bytes32 eip712DomainHash = EIP712_DOMAIN_HASH;

        // Assembly for more efficient computing:
        // keccak256(abi.encodePacked(
        //     EIP191_HEADER,
        //     EIP712_DOMAIN_HASH,
        //     hashStruct
        // ));

        assembly {
            // Load free memory pointer
            let memPtr := mload(64)

            mstore(memPtr, 0x1901000000000000000000000000000000000000000000000000000000000000)  // EIP191 header
            mstore(add(memPtr, 2), eip712DomainHash)                                            // EIP712 domain hash
            mstore(add(memPtr, 34), hashStruct)                                                 // Hash of struct

            // Compute hash
            result := keccak256(memPtr, 66)
        }
        return result;
    }
}

// File: contracts/exchange_handlers/interfaces/zeroex/LibOrder.sol

/*

  Copyright 2018 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

contract LibOrder is
    LibEIP712
{
    // Hash for the EIP712 Order Schema
    bytes32 constant internal EIP712_ORDER_SCHEMA_HASH = keccak256(abi.encodePacked(
        "Order(",
        "address makerAddress,",
        "address takerAddress,",
        "address feeRecipientAddress,",
        "address senderAddress,",
        "uint256 makerAssetAmount,",
        "uint256 takerAssetAmount,",
        "uint256 makerFee,",
        "uint256 takerFee,",
        "uint256 expirationTimeSeconds,",
        "uint256 salt,",
        "bytes makerAssetData,",
        "bytes takerAssetData",
        ")"
    ));

    // A valid order remains fillable until it is expired, fully filled, or cancelled.
    // An order's state is unaffected by external factors, like account balances.
    enum OrderStatus {
        INVALID,                     // Default value
        INVALID_MAKER_ASSET_AMOUNT,  // Order does not have a valid maker asset amount
        INVALID_TAKER_ASSET_AMOUNT,  // Order does not have a valid taker asset amount
        FILLABLE,                    // Order is fillable
        EXPIRED,                     // Order has already expired
        FULLY_FILLED,                // Order is fully filled
        CANCELLED                    // Order has been cancelled
    }

    // solhint-disable max-line-length
    struct Order {
        address makerAddress;           // Address that created the order.
        address takerAddress;           // Address that is allowed to fill the order. If set to 0, any address is allowed to fill the order.
        address feeRecipientAddress;    // Address that will recieve fees when order is filled.
        address senderAddress;          // Address that is allowed to call Exchange contract methods that affect this order. If set to 0, any address is allowed to call these methods.
        uint256 makerAssetAmount;       // Amount of makerAsset being offered by maker. Must be greater than 0.
        uint256 takerAssetAmount;       // Amount of takerAsset being bid on by maker. Must be greater than 0.
        uint256 makerFee;               // Amount of ZRX paid to feeRecipient by maker when order is filled. If set to 0, no transfer of ZRX from maker to feeRecipient will be attempted.
        uint256 takerFee;               // Amount of ZRX paid to feeRecipient by taker when order is filled. If set to 0, no transfer of ZRX from taker to feeRecipient will be attempted.
        uint256 expirationTimeSeconds;  // Timestamp in seconds at which order expires.
        uint256 salt;                   // Arbitrary number to facilitate uniqueness of the order's hash.
        bytes makerAssetData;           // Encoded data that can be decoded by a specified proxy contract when transferring makerAsset. The last byte references the id of this proxy.
        bytes takerAssetData;           // Encoded data that can be decoded by a specified proxy contract when transferring takerAsset. The last byte references the id of this proxy.
    }
    // solhint-enable max-line-length

    struct OrderInfo {
        uint8 orderStatus;                    // Status that describes order's validity and fillability.
        bytes32 orderHash;                    // EIP712 hash of the order (see LibOrder.getOrderHash).
        uint256 orderTakerAssetFilledAmount;  // Amount of order that has already been filled.
    }

    /// @dev Calculates Keccak-256 hash of the order.
    /// @param order The order structure.
    /// @return Keccak-256 EIP712 hash of the order.
    function getOrderHash(Order memory order)
        internal
        view
        returns (bytes32 orderHash)
    {
        orderHash = hashEIP712Message(hashOrder(order));
        return orderHash;
    }

    /// @dev Calculates EIP712 hash of the order.
    /// @param order The order structure.
    /// @return EIP712 hash of the order.
    function hashOrder(Order memory order)
        internal
        pure
        returns (bytes32 result)
    {
        bytes32 schemaHash = EIP712_ORDER_SCHEMA_HASH;
        bytes32 makerAssetDataHash = keccak256(order.makerAssetData);
        bytes32 takerAssetDataHash = keccak256(order.takerAssetData);

        // Assembly for more efficiently computing:
        // keccak256(abi.encodePacked(
        //     EIP712_ORDER_SCHEMA_HASH,
        //     bytes32(order.makerAddress),
        //     bytes32(order.takerAddress),
        //     bytes32(order.feeRecipientAddress),
        //     bytes32(order.senderAddress),
        //     order.makerAssetAmount,
        //     order.takerAssetAmount,
        //     order.makerFee,
        //     order.takerFee,
        //     order.expirationTimeSeconds,
        //     order.salt,
        //     keccak256(order.makerAssetData),
        //     keccak256(order.takerAssetData)
        // ));

        assembly {
            // Calculate memory addresses that will be swapped out before hashing
            let pos1 := sub(order, 32)
            let pos2 := add(order, 320)
            let pos3 := add(order, 352)

            // Backup
            let temp1 := mload(pos1)
            let temp2 := mload(pos2)
            let temp3 := mload(pos3)

            // Hash in place
            mstore(pos1, schemaHash)
            mstore(pos2, makerAssetDataHash)
            mstore(pos3, takerAssetDataHash)
            result := keccak256(pos1, 416)

            // Restore
            mstore(pos1, temp1)
            mstore(pos2, temp2)
            mstore(pos3, temp3)
        }
        return result;
    }
}

// File: contracts/exchange_handlers/interfaces/zeroex/LibFillResults.sol

/*

  Copyright 2018 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

contract LibFillResults
{
    struct FillResults {
        uint256 makerAssetFilledAmount;  // Total amount of makerAsset(s) filled.
        uint256 takerAssetFilledAmount;  // Total amount of takerAsset(s) filled.
        uint256 makerFeePaid;            // Total amount of ZRX paid by maker(s) to feeRecipient(s).
        uint256 takerFeePaid;            // Total amount of ZRX paid by taker to feeRecipients(s).
    }

    struct MatchedFillResults {
        FillResults left;                    // Amounts filled and fees paid of left order.
        FillResults right;                   // Amounts filled and fees paid of right order.
        uint256 leftMakerAssetSpreadAmount;  // Spread between price of left and right order, denominated in the left order's makerAsset, paid to taker.
    }

    /// @dev Adds properties of both FillResults instances.
    ///      Modifies the first FillResults instance specified.
    /// @param totalFillResults Fill results instance that will be added onto.
    /// @param singleFillResults Fill results instance that will be added to totalFillResults.
    function addFillResults(FillResults memory totalFillResults, FillResults memory singleFillResults)
        internal
        pure
    {
        totalFillResults.makerAssetFilledAmount = SafeMath.add(totalFillResults.makerAssetFilledAmount, singleFillResults.makerAssetFilledAmount);
        totalFillResults.takerAssetFilledAmount = SafeMath.add(totalFillResults.takerAssetFilledAmount, singleFillResults.takerAssetFilledAmount);
        totalFillResults.makerFeePaid = SafeMath.add(totalFillResults.makerFeePaid, singleFillResults.makerFeePaid);
        totalFillResults.takerFeePaid = SafeMath.add(totalFillResults.takerFeePaid, singleFillResults.takerFeePaid);
    }
}

contract IExchangeCore {

    bytes public ZRX_ASSET_DATA;

    /// @dev Fills the input order.
    /// @param order Order struct containing order specifications.
    /// @param takerAssetFillAmount Desired amount of takerAsset to sell.
    /// @param signature Proof that order has been created by maker.
    /// @return Amounts filled and fees paid by maker and taker.
    function fillOrder(
        LibOrder.Order memory order,
        uint256 takerAssetFillAmount,
        bytes memory signature
    )
        public
        returns (LibFillResults.FillResults memory fillResults);

    function fillOrderNoThrow(
        LibOrder.Order memory order,
        uint256 takerAssetFillAmount,
        bytes memory signature
    )
        public
        returns (LibFillResults.FillResults memory fillResults);

    /// @dev Gets information about an order: status, hash, and amount filled.
    /// @param order Order to gather information on.
    /// @return OrderInfo Information about the order and its state.
    ///                   See LibOrder.OrderInfo for a complete description.
    function getOrderInfo(LibOrder.Order memory order)
        public
        view
        returns (LibOrder.OrderInfo memory orderInfo);

    /// @dev Gets an asset proxy.
    /// @param assetProxyId Id of the asset proxy.
    /// @return The asset proxy registered to assetProxyId. Returns 0x0 if no proxy is registered.
    function getAssetProxy(bytes4 assetProxyId)
        external
        view
        returns (address);

    function isValidSignature(
        bytes32 hash,
        address signerAddress,
        bytes memory signature
    )
        public
        view
        returns (bool isValid);
}

/// @title A contract which can be used to ensure only the TotlePrimary contract can call
/// some functions
/// @dev Defines a modifier which should be used when only the totle contract should
/// able able to call a function
contract TotleControl is Ownable {
    mapping(address => bool) public authorizedPrimaries;

    /// @dev A modifier which only allows code execution if msg.sender equals totlePrimary address
    modifier onlyTotle() {
        require(authorizedPrimaries[msg.sender]);
        _;
    }

    /// @notice Contract constructor
    /// @dev As this contract inherits ownable, msg.sender will become the contract owner
    /// @param _totlePrimary the address of the contract to be set as totlePrimary
    constructor(address _totlePrimary) public {
        authorizedPrimaries[_totlePrimary] = true;
    }

    /// @notice A function which allows only the owner to change the address of totlePrimary
    /// @dev onlyOwner modifier only allows the contract owner to run the code
    /// @param _totlePrimary the address of the contract to be set as totlePrimary
    function addTotle(
        address _totlePrimary
    ) external onlyOwner {
        authorizedPrimaries[_totlePrimary] = true;
    }

    function removeTotle(
        address _totlePrimary
    ) external onlyOwner {
        authorizedPrimaries[_totlePrimary] = false;
    }
}

interface WETH {
    function deposit() external payable;
    function withdraw(uint256 amount) external;
}


/// @title ZeroExExchangeHandler
/// @notice Handles the all ZeroExExchange trades for the primary contract
contract ZeroExExchangeHandler is TotleControl, ExchangeHandler, AllowanceSetter  {

    /*
    *   State Variables
    */

    IExchangeCore public exchange;
    /// @dev note that this is dependent on the deployment of 0xV2. This is the ERC20 asset proxy + the mainnet address of the ZRX token
    bytes constant ZRX_ASSET_DATA = "\xf4\x72\x61\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x1d\x24\x89\x57\x1d\x32\x21\x89\x24\x6d\xaf\xa5\xeb\xde\x1f\x46\x99\xf4\x98";
    address ERC20_ASSET_PROXY;
    WETH weth;

    /*
    *   Types
    */

    /// @notice Constructor
    /// @param _exchange Address of the IExchangeCore exchange
    constructor(
        address _exchange,
        address _weth,
        address _primary
    ) TotleControl(_primary)
        public
    {
        exchange = IExchangeCore(_exchange);
        ERC20_ASSET_PROXY = exchange.getAssetProxy(toBytes4(ZRX_ASSET_DATA, 0));
        weth = WETH(_weth);
    }


    struct OrderData {
        address makerAddress;           // Address that created the order.
        address takerAddress;           // Address that is allowed to fill the order. If set to 0, any address is allowed to fill the order.
        address feeRecipientAddress;    // Address that will recieve fees when order is filled.
        address senderAddress;          // Address that is allowed to call Exchange contract methods that affect this order. If set to 0, any address is allowed to call these methods.
        uint256 makerAssetAmount;       // Amount of makerAsset being offered by maker. Must be greater than 0.
        uint256 takerAssetAmount;       // Amount of takerAsset being bid on by maker. Must be greater than 0.
        uint256 makerFee;               // Amount of ZRX paid to feeRecipient by maker when order is filled. If set to 0, no transfer of ZRX from maker to feeRecipient will be attempted.
        uint256 takerFee;               // Amount of ZRX paid to feeRecipient by taker when order is filled. If set to 0, no transfer of ZRX from taker to feeRecipient will be attempted.
        uint256 expirationTimeSeconds;  // Timestamp in seconds at which order expires.
        uint256 salt;                   // Arbitrary number to facilitate uniqueness of the order's hash.
        bytes makerAssetData;           // Encoded data that can be decoded by a specified proxy contract when transferring makerAsset. The last byte references the id of this proxy.
        bytes takerAssetData;           // Encoded data that can be decoded by a specified proxy contract when transferring takerAsset. The last byte references the id of this proxy.
        bytes signature;
    }

    /*
    *   Public functions
    */



    /*
    *   Internal functions
    */

    /// @notice Gets the amount that Totle needs to give for this order
    /// @param data LibOrder.Order struct containing order values
    /// @return amountToGive amount taker needs to give in order to fill the order
    function getAmountToGive_(
        OrderData memory data
    )
      internal
      view
      returns (uint256 amountToGive)
    {
        LibOrder.OrderInfo memory orderInfo = exchange.getOrderInfo(
            getZeroExOrder(data)
        );
        uint makerAssetAvailable = getAssetDataAvailable(data.makerAssetData, data.makerAddress);
        uint feeAssetAvailable = getAssetDataAvailable(ZRX_ASSET_DATA, data.makerAddress);

        uint maxFromMakerFee = data.makerFee == 0 ? Utils.max_uint() : getPartialAmount(feeAssetAvailable, data.makerFee, data.takerAssetAmount);
        amountToGive = Math.min(Math.min(
            getPartialAmount(makerAssetAvailable, data.makerAssetAmount, data.takerAssetAmount),
            maxFromMakerFee),
            SafeMath.sub(data.takerAssetAmount, orderInfo.orderTakerAssetFilledAmount)
        );
        //TODO add in taker fee shit - both in calculating this and actually buying the ZRX
        /* logger.log("Getting amountToGive from ZeroEx arg2: amountToGive", amountToGive); */
    }

    function getAssetDataAvailable(bytes memory assetData, address account) internal view returns (uint){
        address tokenAddress = toAddress(assetData, 16);
        ERC20 token = ERC20(tokenAddress);
        return Math.min(token.balanceOf(account), token.allowance(account, ERC20_ASSET_PROXY));
    }

    function getZeroExOrder(OrderData memory data) internal pure returns (LibOrder.Order memory) {
        return LibOrder.Order({
            makerAddress: data.makerAddress,
            takerAddress: data.takerAddress,
            feeRecipientAddress: data.feeRecipientAddress,
            senderAddress: data.senderAddress,
            makerAssetAmount: data.makerAssetAmount,
            takerAssetAmount: data.takerAssetAmount,
            makerFee: data.makerFee,
            takerFee: data.takerFee,
            expirationTimeSeconds: data.expirationTimeSeconds,
            salt: data.salt,
            makerAssetData: data.makerAssetData,
            takerAssetData: data.takerAssetData
        });
    }

    /// @notice Perform exchange-specific checks on the given order
    /// @dev This should be called to check for payload errors
    /// @param data LibOrder.Order struct containing order values
    /// @return checksPassed value representing pass or fail
    function staticExchangeChecks(
        OrderData memory data
    )
        internal
        view
        returns (bool checksPassed)
    {

        // Make sure that:
        //  The order is not expired
        //  Both the maker and taker assets are ERC20 tokens
        //  The taker does not have to pay a fee (we don't support fees yet)
        //  We are permitted to take this order
        //  We are permitted to send this order
        // TODO: Should we check signatures here?
        return (block.timestamp <= data.expirationTimeSeconds &&
                toBytes4(data.takerAssetData, 0) == bytes4(0xf47261b0) &&
                toBytes4(data.makerAssetData, 0) == bytes4(0xf47261b0) &&
                data.takerFee == 0 &&
                (data.takerAddress == address(0x0) || data.takerAddress == address(this)) &&
                (data.senderAddress == address(0x0) || data.senderAddress == address(this))
        );
    }

    function performOrder(
        bytes memory genericPayload,
        uint256 availableToSpend,
        uint256 targetAmount,
        bool targetAmountIsSource
    )
        public
        payable
        onlyTotle
        returns (uint256 amountSpentOnOrder, uint256 amountReceivedFromOrder)
    {
        OrderData memory data = abi.decode(genericPayload, (OrderData));
        address sourceAddress = toAddress(data.takerAssetData, 16);
        if(!staticExchangeChecks(data)){
            if(sourceAddress == address(weth)){
                msg.sender.transfer(availableToSpend);
            } else {
                ERC20SafeTransfer.safeTransfer(sourceAddress, msg.sender, availableToSpend); 
            }
            return (0,0);

        }
        if(sourceAddress == address(weth)){
            weth.deposit.value(availableToSpend)();
        }
        approveAddress(ERC20_ASSET_PROXY, sourceAddress);

        LibFillResults.FillResults memory results = exchange.fillOrder(
            getZeroExOrder(data),
            Math.min(targetAmount, Math.min(availableToSpend, getAmountToGive_(data))),
            data.signature
        );

        amountSpentOnOrder = results.takerAssetFilledAmount;
        amountReceivedFromOrder = results.makerAssetFilledAmount;

        if(amountSpentOnOrder < availableToSpend){
            if(sourceAddress == address(weth)){
                weth.withdraw(availableToSpend - amountSpentOnOrder);
                msg.sender.transfer(availableToSpend - amountSpentOnOrder);
            } else {
                ERC20SafeTransfer.safeTransfer(sourceAddress, msg.sender, availableToSpend - amountSpentOnOrder);
            }
        }

        address destinationAddress = toAddress(data.makerAssetData, 16);

        if(destinationAddress == address(weth)){
            weth.withdraw(amountReceivedFromOrder);
            msg.sender.transfer(amountReceivedFromOrder);
        } else {
            ERC20SafeTransfer.safeTransfer(destinationAddress, msg.sender, amountReceivedFromOrder);
        }


    }

    /// @notice Calculate the result of ((numerator * target) / denominator)
    /// @param numerator the numerator in the equation
    /// @param denominator the denominator in the equation
    /// @param target the target for the equations
    /// @return partialAmount the resultant value
    function getPartialAmount(
        uint256 numerator,
        uint256 denominator,
        uint256 target
    )
        internal
        pure
        returns (uint256)
    {
        return SafeMath.div(SafeMath.mul(numerator, target), denominator);
    }

    // @notice Extract an address from a string of bytes
    // @param _bytes a string of at least 20 bytes
    // @param _start the offset of the address within the byte stream
    // @return tempAddress the address encoded in the bytestring beginning at _start
    function toAddress(bytes memory _bytes, uint _start) internal  pure returns (address) {
        require(_bytes.length >= (_start + 20));
        address tempAddress;

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

        return tempAddress;
    }

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

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

    // @notice Extract a uint256 from a string of bytes
    // @param _bytes a string of at least 32 bytes
    // @param _start the offset of the uint256 within the byte stream
    // @return tempUint the uint encoded in the bytestring beginning at _start
    function toUint(bytes memory _bytes, uint _start) internal  pure returns (uint256) {
        require(_bytes.length >= (_start + 32));
        uint256 tempUint;

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

        return tempUint;
    }

    /*
    *   Payable fallback function
    */

    /// @notice payable fallback to allow the exchange to return ether directly to this contract
    /// @dev note that only the exchange should be able to send ether to this contract
    function() external payable {
        require(msg.sender == address(weth));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":false,"inputs":[{"name":"genericPayload","type":"bytes"},{"name":"availableToSpend","type":"uint256"},{"name":"targetAmount","type":"uint256"},{"name":"targetAmountIsSource","type":"bool"}],"name":"performOrder","outputs":[{"name":"amountSpentOnOrder","type":"uint256"},{"name":"amountReceivedFromOrder","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"_totlePrimary","type":"address"}],"name":"addTotle","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unpause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_token","type":"address"},{"name":"_amount","type":"uint256"}],"name":"withdrawToken","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_totlePrimary","type":"address"}],"name":"removeTotle","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"authorizedPrimaries","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"exchange","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_amount","type":"uint256"}],"name":"withdrawETH","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_exchange","type":"address"},{"name":"_weth","type":"address"},{"name":"_primary","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"}],"name":"OwnershipRenounced","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]

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

000000000000000000000000080bf510fcbf18b91105470639e9561022937712000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000003179e4cd7ff08eb14397e1c402d0de44e1523f2e

-----Decoded View---------------
Arg [0] : _exchange (address): 0x080bf510FCbF18b91105470639e9561022937712
Arg [1] : _weth (address): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
Arg [2] : _primary (address): 0x3179E4Cd7fF08EB14397E1C402d0De44E1523f2e

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000080bf510fcbf18b91105470639e9561022937712
Arg [1] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
Arg [2] : 0000000000000000000000003179e4cd7ff08eb14397e1c402d0de44e1523f2e

31595:10855:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42433:4;;-1:-1:-1;;;;;42433:4:0;42411:10;:27;42403:36;;;;;;31595:10855;37971:2102;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;31078:136;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;31078:136:0;;;;;;;;:::i;15894:97::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15894:97:0;;;:::i;15179:72::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15179:72:0;;;:::i;:::-;;;;;;;;13086:114;;8:9:-1;5:2;;;30:1;27;20:12;5:2;13086:114:0;;;:::i;15712:95::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15712:95:0;;;:::i;12283:28::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;12283:28:0;;;:::i;:::-;;;;;;;;14347:170;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;14347:170:0;;;;;;;;:::i;31222:140::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;31222:140:0;;;;;;;;:::i;30237:51::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;30237:51:0;;;;;;;;:::i;31729:29::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;31729:29:0;;;:::i;:::-;;;;;;;;14768:99;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;14768:99:0;;;;;;;;:::i;13368:113::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;13368:113:0;;;;;;;;:::i;37971:2102::-;30457:10;38210:26;30437:31;;;:19;:31;;;;;;38210:26;;30437:31;;30429:40;;;;;;38287:21;;:::i;:::-;38322:14;38311:39;;;;;;;;;;;;;;38287:63;;38361:21;38385:34;38395:4;:19;;;38416:2;38385:9;:34::i;:::-;38361:58;;38434:26;38455:4;38434:20;:26::i;:::-;38430:309;;38504:4;;-1:-1:-1;;;;;38479:30:0;;;38504:4;;38479:30;38476:223;;;38529:37;;:10;;:37;;;;;38549:16;;38529:37;;;;38549:16;38529:10;:37;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;38529:37:0;38476:223;;;38607:75;38638:13;38653:10;38665:16;38607:30;:75::i;:::-;;38476:223;-1:-1:-1;38721:1:0;;-1:-1:-1;38721:1:0;;-1:-1:-1;38713:12:0;;-1:-1:-1;38713:12:0;38430:309;38777:4;;-1:-1:-1;;;;;38752:30:0;;;38777:4;;38752:30;38749:99;;;38798:4;;;:38;;;;;;;;-1:-1:-1;;;;;38798:4:0;;;;:12;;38817:16;;38798:38;;;;:4;;:38;;;;;;38817:16;38798:4;:38;;;5:2:-1;;;;30:1;27;20:12;5:2;38798:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;38798:38:0;;;;;38749:99;38873:17;;38858:48;;-1:-1:-1;;;;;38873:17:0;38892:13;38858:14;:48::i;:::-;38919:41;;:::i;:::-;38963:8;;;;;-1:-1:-1;;;;;38963:8:0;:18;38996:20;39011:4;38996:14;:20::i;:::-;39031:74;39040:12;39054:50;39063:16;39081:22;39098:4;39081:16;:22::i;:::-;39054:8;:50::i;39031:74::-;39120:4;:14;;;38963:182;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;38963:182:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;38963:182:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;38963:182:0;;;;;;;;;39179:30;;;;39246;;39179;;-1:-1:-1;39246:30:0;-1:-1:-1;38919:226:0;-1:-1:-1;39292:37:0;;;39289:402;;;39373:4;;-1:-1:-1;;;;;39348:30:0;;;39373:4;;39348:30;39345:335;;;39398:4;;;:52;;;;;-1:-1:-1;;;;;39398:4:0;;;;:13;;:52;;39412:37;;;;39398:52;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;39398:52:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;39469:58:0;;:10;;-1:-1:-1;39489:37:0;;;39469:58;;;;;-1:-1:-1;39489:37:0;39469:58;;;;39489:37;39469:10;:58;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;39469:58:0;39345:335;;;39568:96;39599:13;39614:10;39645:18;39626:16;:37;39568:30;:96::i;:::-;;39345:335;39703:26;39732:34;39742:4;:19;;;39763:2;39732:9;:34::i;:::-;39812:4;;39703:63;;-1:-1:-1;;;;;;39782:35:0;;;39812:4;;39782:35;39779:283;;;39833:4;;;:38;;;;;-1:-1:-1;;;;;39833:4:0;;;;:13;;:38;;39847:23;;39833:38;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;39833:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;39886:44:0;;:10;;-1:-1:-1;39886:44:0;;;;;-1:-1:-1;39906:23:0;;39886:44;;;;39906:23;39886:10;:44;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;39886:44:0;39779:283;;;39963:87;39994:18;40014:10;40026:23;39963:30;:87::i;:::-;;39779:283;30480:1;;;;;37971:2102;;;;;;;:::o;31078:136::-;12794:5;;-1:-1:-1;;;;;12794:5:0;12780:10;:19;12772:28;;;;;;-1:-1:-1;;;;;31165:34:0;;;;;31202:4;31165:34;;;;;;;;:41;;-1:-1:-1;;31165:41:0;;;;;;31078:136::o;15894:97::-;12794:5;;-1:-1:-1;;;;;12794:5:0;12780:10;:19;12772:28;;;;;;15582:7;;;;15574:40;;;;-1:-1:-1;;;;;15574:40:0;;;;;;;;;;;;;;;;;15948:7;:15;;-1:-1:-1;;15948:15:0;;;15975:10;;;;15958:5;;15975:10;15894:97::o;15179:72::-;15238:7;;;;15179:72;:::o;13086:114::-;12794:5;;-1:-1:-1;;;;;12794:5:0;12780:10;:19;12772:28;;;;;;13163:5;;;13144:25;;-1:-1:-1;;;;;13163:5:0;;;;13144:25;;;13192:1;13176:18;;-1:-1:-1;;13176:18:0;;;13086:114::o;15712:95::-;12794:5;;-1:-1:-1;;;;;12794:5:0;12780:10;:19;12772:28;;;;;;15398:7;;;;15397:8;15389:40;;;;-1:-1:-1;;;;;15389:40:0;;;;;;;;;15767:7;:14;;-1:-1:-1;;15767:14:0;15777:4;15767:14;;;15793:8;;;;15767:7;;15793:8;15712:95::o;12283:28::-;;;-1:-1:-1;;;;;12283:28:0;;:::o;14347:170::-;14431:4;12794:5;;-1:-1:-1;;;;;12794:5:0;12780:10;:19;12772:28;;;;;;14494:5;;14455:54;;14486:6;;-1:-1:-1;;;;;14494:5:0;14501:7;14455:30;:54::i;:::-;14448:61;;12807:1;14347:170;;;;:::o;31222:140::-;12794:5;;-1:-1:-1;;;;;12794:5:0;12780:10;:19;12772:28;;;;;;-1:-1:-1;;;;;31312:34:0;31349:5;31312:34;;;:19;:34;;;;;:42;;-1:-1:-1;;31312:42:0;;;31222:140::o;30237:51::-;;;;;;;;;;;;;;;:::o;31729:29::-;;;;;;-1:-1:-1;;;;;31729:29:0;;:::o;14768:99::-;12794:5;;-1:-1:-1;;;;;12794:5:0;12780:10;:19;12772:28;;;;;;14836:5;;;:23;;-1:-1:-1;;;;;14836:5:0;;;;:23;;;;;14851:7;;14836:23;:5;:23;14851:7;14836:5;:23;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14836:23:0;14768:99;:::o;13368:113::-;12794:5;;-1:-1:-1;;;;;12794:5:0;12780:10;:19;12772:28;;;;;;13446:29;13465:9;13446:18;:29::i;:::-;13368:113;:::o;40917:338::-;40994:7;41040:6;41049:2;41040:11;41022:6;:13;:30;;41014:39;;;;;;-1:-1:-1;41145:30:0;41161:4;41145:30;41139:37;41178:27;41135:71;;;40917:338::o;37001:962::-;37120:17;37539:4;:26;;;37520:15;:45;;:120;;;;-1:-1:-1;37595:19:0;;;;37622:18;;37586:32;;37616:1;37586:8;:32::i;:::-;:54;;;37520:120;:195;;;;-1:-1:-1;37670:19:0;;;;37697:18;;37661:32;;37691:1;37661:8;:32::i;:::-;:54;;;37520:195;:234;;;;-1:-1:-1;37736:13:0;;;;:18;37520:234;:328;;;;-1:-1:-1;37776:17:0;;;;-1:-1:-1;;;;;37776:33:0;;;:71;;-1:-1:-1;37813:17:0;;;;-1:-1:-1;;;;;37813:34:0;37842:4;37813:34;37776:71;37520:424;;;;-1:-1:-1;37870:18:0;;;;-1:-1:-1;;;;;37870:34:0;;;:73;;-1:-1:-1;;37908:18:0;;;-1:-1:-1;;;;;37908:35:0;37938:4;37908:35;;37001:962::o;9746:306::-;9838:12;9876:13;-1:-1:-1;;;;;9876:18:0;9948:3;9953:6;9895:65;;;;;;;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;9895:65:0;;;49:4:-1;25:18;;61:17;;9895:65:0;182:15:-1;9895:65:0;179:29:-1;160:49;;9876:85:0;;;9895:65;9876:85;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;9863:98:0;;;;;9980:7;9972:35;;;;-1:-1:-1;;;;;9972:35:0;;;;;;;;;10027:17;:15;:17::i;:::-;10020:24;;9746:306;;;;;;:::o;11801:257::-;11889:55;;;;;-1:-1:-1;;;;;11889:22:0;;;;;:55;;11920:4;;11927:16;;11889:55;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;11889:55:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;11889:55:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;11889:55:0;;;;;;;;;11886:165;;11974:64;12004:5;12011:16;-1:-1:-1;;11974:29:0;:64::i;:::-;11966:73;;;;;36007:724;36077:21;;:::i;:::-;36118:605;;;;;;;;36162:4;:17;;;-1:-1:-1;;;;;36118:605:0;;;;;36208:4;:17;;;-1:-1:-1;;;;;36118:605:0;;;;;36261:4;:24;;;-1:-1:-1;;;;;36118:605:0;;;;;36315:4;:18;;;-1:-1:-1;;;;;36118:605:0;;;;;36366:4;:21;;;36118:605;;;;36420:4;:21;;;36118:605;;;;36466:4;:13;;;36118:605;;;;36504:4;:13;;;36118:605;;;;36555:4;:26;;;36118:605;;;;36602:4;:9;;;36118:605;;;;36642:4;:19;;;36118:605;;;;36692:4;:19;;;36118:605;;;36111:612;;36007:724;;;:::o;34623:1061::-;34732:20;34770:35;;:::i;:::-;34808:8;;;;;-1:-1:-1;;;;;34808:8:0;:21;34844:20;34859:4;34844:14;:20::i;:::-;34808:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;34808:67:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;34808:67:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;34808:67:0;;;;;;;;;34770:105;;34886:24;34913:61;34935:4;:19;;;34956:4;:17;;;34913:21;:61::i;:::-;34886:88;;34985:22;35010:56;35032:14;;;;;;;;;;;;;;;;;35048:17;;35010:21;:56::i;:::-;34985:81;;35079:20;35102:4;:13;;;35119:1;35102:18;:113;;35142:73;35159:17;35178:4;:13;;;35193:4;:21;;;35142:16;:73::i;:::-;35102:113;;;35123:16;:14;:16::i;:::-;35079:136;;35241:246;35250:137;35273:83;35290:19;35311:4;:21;;;35334:4;:21;;;35273:16;:83::i;:::-;35371:15;35250:8;:137::i;:::-;35402:74;35415:4;:21;;;35438:9;:37;;;35402:12;:74::i;35241:246::-;35226:261;34623:1061;-1:-1:-1;;;;;;34623:1061:0:o;1963:100::-;2021:7;2048:1;2044;:5;:13;;2056:1;2044:13;;;-1:-1:-1;2052:1:0;;1963:100;-1:-1:-1;1963:100:0:o;13622:183::-;-1:-1:-1;;;;;13701:23:0;;13693:32;;;;;;13758:5;;;13737:38;;-1:-1:-1;;;;;13737:38:0;;;;13758:5;;;13737:38;;;13782:5;:17;;-1:-1:-1;;13782:17:0;-1:-1:-1;;;;;13782:17:0;;;;;;;;;;13622:183::o;41263:294::-;41338:6;41383;41392:1;41383:10;41365:6;:13;:29;;41357:38;;;;;;-1:-1:-1;41480:30:0;41496:4;41480:30;41474:37;;41263:294::o;10739:391::-;10789:12;10844:16;10874:53;;;;10946:2;10941:103;;;;11095:1;11092;11085:12;10874:53;10911:1;10900:12;;10874:53;;10941:103;10989:2;10986:1;10983;10968:24;11027:1;11021:8;11010:19;;10837:275;;10822:301;:::o;10417:314::-;10513:12;10551:13;-1:-1:-1;;;;;10551:18:0;10622:8;10632:6;10570:69;;;;;;;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;10570:69:0;;;49:4:-1;25:18;;61:17;;10570:69:0;182:15:-1;10570:69:0;179:29:-1;160:49;;10551:89:0;;;10570:69;10551:89;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;10538:102:0;;;;;10659:7;10651:35;;;;-1:-1:-1;;;;;10651:35:0;;;;;;;;35692:307;35787:4;35803:20;35826:24;35836:9;35847:2;35826:9;:24::i;:::-;35921;;;;;35803:47;;-1:-1:-1;35803:47:0;;35912:79;;-1:-1:-1;;;;;35921:15:0;;;;;:24;;35937:7;;35921:24;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35921:24:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;35921:24:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;35921:24:0;;;;;;;;;35972:17;;35947:43;;;;;-1:-1:-1;;;;;35947:15:0;;;;;;:43;;35963:7;;35972:17;;35947:43;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35947:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;35947:43:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;35947:43:0;;;;;;;;35912:79;35905:86;35692:307;-1:-1:-1;;;;;35692:307:0:o;40378:264::-;40544:7;40576:58;40589:31;40602:9;40613:6;40589:12;:31::i;:::-;40622:11;40576:12;:58::i;4134:72::-;-1:-1:-1;;4134:72:0;:::o;1166:142::-;1226:7;1256:2;1250;:8;;1242:17;;;;;;-1:-1:-1;1278:7:0;;;1166:142::o;248:400::-;308:7;536;532:38;;-1:-1:-1;561:1:0;554:8;;532:38;590:7;;;595:2;590;:7;:2;612:6;;;;;:12;604:21;;;;;763:285;823:7;852:1;847:2;:6;839:15;;;;;;919:9;936:2;931;:7;;;;;;;763:285;-1:-1:-1;;;;763:285:0:o;31595:10855::-;;;;;;;;;;-1:-1:-1;;;;;31595:10855:0;;;;;;-1:-1:-1;;;;;31595:10855:0;;;;;;-1:-1:-1;;;;;31595:10855:0;;;;;;-1:-1:-1;;;;;31595:10855:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;-1:-1:-1;;;;;31595:10855:0;;;;;;-1:-1:-1;;;;;31595:10855:0;;;;;;-1:-1:-1;;;;;31595:10855:0;;;;;;-1:-1:-1;;;;;31595:10855:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;-1:-1:-1;31595:10855:0;;;;;;;;;;;;;;;;;:::o;5:118:-1:-;;72:46;110:6;97:20;72:46;;130:122;;208:39;239:6;233:13;208:39;;400:112;;464:43;499:6;486:20;464:43;;519:122;;597:39;628:6;622:13;597:39;;649:434;;757:3;750:4;742:6;738:17;734:27;724:2;;775:1;772;765:12;724:2;805:6;799:13;827:60;842:44;879:6;842:44;;;827:60;;;818:69;;907:6;900:5;893:21;943:4;935:6;931:17;976:4;969:5;965:16;1011:3;1002:6;997:3;993:16;990:25;987:2;;;1028:1;1025;1018:12;987:2;1038:39;1070:6;1065:3;1060;1038:39;;;717:366;;;;;;;;1092:440;;1193:3;1186:4;1178:6;1174:17;1170:27;1160:2;;1211:1;1208;1201:12;1160:2;1248:6;1235:20;1270:64;1285:48;1326:6;1285:48;;1270:64;1261:73;;1354:6;1347:5;1340:21;1390:4;1382:6;1378:17;1423:4;1416:5;1412:16;1458:3;1449:6;1444:3;1440:16;1437:25;1434:2;;;1475:1;1472;1465:12;1434:2;1485:41;1519:6;1514:3;1509;1485:41;;1580:865;;1709:4;1697:9;1692:3;1688:19;1684:30;1681:2;;;1727:1;1724;1717:12;1681:2;1745:20;1760:4;1745:20;;;1736:29;-1:-1;1833:1;1864:60;1920:3;1900:9;1864:60;;;1840:85;;-1:-1;2004:2;2037:60;2093:3;2069:22;;;2037:60;;;2030:4;2023:5;2019:16;2012:86;1946:163;2167:2;2200:60;2256:3;2247:6;2236:9;2232:22;2200:60;;;2193:4;2186:5;2182:16;2175:86;2119:153;2330:2;2363:60;2419:3;2410:6;2399:9;2395:22;2363:60;;;2356:4;2349:5;2345:16;2338:86;2282:153;1675:770;;;;;2497:2584;;2620:5;2608:9;2603:3;2599:19;2595:31;2592:2;;;2639:1;2636;2629:12;2592:2;2657:21;2672:5;2657:21;;;2648:30;-1:-1;2736:1;2767:60;2823:3;2803:9;2767:60;;;2743:85;;-1:-1;2897:2;2930:60;2986:3;2962:22;;;2930:60;;;2923:4;2916:5;2912:16;2905:86;2849:153;3067:2;3100:60;3156:3;3147:6;3136:9;3132:22;3100:60;;;3093:4;3086:5;3082:16;3075:86;3012:160;3231:2;3264:60;3320:3;3311:6;3300:9;3296:22;3264:60;;;3257:4;3250:5;3246:16;3239:86;3182:154;3398:3;3432:60;3488:3;3479:6;3468:9;3464:22;3432:60;;;3425:4;3418:5;3414:16;3407:86;3346:158;3566:3;3600:60;3656:3;3647:6;3636:9;3632:22;3600:60;;;3593:4;3586:5;3582:16;3575:86;3514:158;3726:3;3760:60;3816:3;3807:6;3796:9;3792:22;3760:60;;;3753:4;3746:5;3742:16;3735:86;3682:150;3886:3;3920:60;3976:3;3967:6;3956:9;3952:22;3920:60;;;3913:4;3906:5;3902:16;3895:86;3842:150;4059:3;4094:60;4150:3;4141:6;4130:9;4126:22;4094:60;;;4086:5;4079;4075:17;4068:87;4002:164;4216:3;4251:60;4307:3;4298:6;4287:9;4283:22;4251:60;;;4243:5;4236;4232:17;4225:87;4176:147;4404:3;4393:9;4389:19;4383:26;4429:18;4421:6;4418:30;4415:2;;;4461:1;4458;4451:12;4415:2;4497:65;4558:3;4549:6;4538:9;4534:22;4497:65;;;4489:5;4482;4478:17;4471:92;4333:241;4655:3;4644:9;4640:19;4634:26;4680:18;4672:6;4669:30;4666:2;;;4712:1;4709;4702:12;4666:2;4748:65;4809:3;4800:6;4789:9;4785:22;4748:65;;;4740:5;4733;4729:17;4722:92;4584:241;4901:3;4890:9;4886:19;4880:26;4926:18;4918:6;4915:30;4912:2;;;4958:1;4955;4948:12;4912:2;4994:65;5055:3;5046:6;5035:9;5031:22;4994:65;;;4986:5;4979;4975:17;4968:92;4835:236;2586:2495;;;;;5120:689;;5247:4;5235:9;5230:3;5226:19;5222:30;5219:2;;;5265:1;5262;5255:12;5219:2;5283:20;5298:4;5283:20;;;5274:29;-1:-1;5360:1;5391:58;5445:3;5425:9;5391:58;;;5367:83;;-1:-1;5516:2;5549:60;5605:3;5581:22;;;5549:60;;;5542:4;5535:5;5531:16;5524:86;5471:150;5694:2;5727:60;5783:3;5774:6;5763:9;5759:22;5727:60;;;5720:4;5713:5;5709:16;5702:86;5631:168;5213:596;;;;;5816:118;;5883:46;5921:6;5908:20;5883:46;;6070:118;;6146:37;6175:6;6169:13;6146:37;;6195:241;;6299:2;6287:9;6278:7;6274:23;6270:32;6267:2;;;6315:1;6312;6305:12;6267:2;6350:1;6367:53;6412:7;6392:9;6367:53;;;6357:63;6261:175;-1:-1;;;;6261:175;6707:366;;;6828:2;6816:9;6807:7;6803:23;6799:32;6796:2;;;6844:1;6841;6834:12;6796:2;6879:1;6896:53;6941:7;6921:9;6896:53;;;6886:63;;6858:97;6986:2;7004:53;7049:7;7040:6;7029:9;7025:22;7004:53;;;6994:63;;6965:98;6790:283;;;;;;7080:715;;;;;7241:3;7229:9;7220:7;7216:23;7212:33;7209:2;;;7258:1;7255;7248:12;7209:2;7293:31;;7344:18;7333:30;;7330:2;;;7376:1;7373;7366:12;7330:2;7396:62;7450:7;7441:6;7430:9;7426:22;7396:62;;;7386:72;;7272:192;7495:2;7513:53;7558:7;7549:6;7538:9;7534:22;7513:53;;;7503:63;;7474:98;7603:2;7621:53;7666:7;7657:6;7646:9;7642:22;7621:53;;;7611:63;;7582:98;7711:2;7729:50;7771:7;7762:6;7751:9;7747:22;7729:50;;;7719:60;;7690:95;7203:592;;;;;;;;7802:322;;7946:3;7934:9;7925:7;7921:23;7917:33;7914:2;;;7963:1;7960;7953:12;7914:2;7998:1;8015:93;8100:7;8080:9;8015:93;;8131:388;;8269:2;8257:9;8248:7;8244:23;8240:32;8237:2;;;8285:1;8282;8275:12;8237:2;8320:24;;8364:18;8353:30;;8350:2;;;8396:1;8393;8386:12;8350:2;8416:87;8495:7;8486:6;8475:9;8471:22;8416:87;;8526:317;;8668:2;8656:9;8647:7;8643:23;8639:32;8636:2;;;8684:1;8681;8674:12;8636:2;8719:1;8736:91;8819:7;8799:9;8736:91;;8850:241;;8954:2;8942:9;8933:7;8929:23;8925:32;8922:2;;;8970:1;8967;8960:12;8922:2;9005:1;9022:53;9067:7;9047:9;9022:53;;9098:263;;9213:2;9201:9;9192:7;9188:23;9184:32;9181:2;;;9229:1;9226;9219:12;9181:2;9264:1;9281:64;9337:7;9317:9;9281:64;;9368:144;9467:39;9500:5;9467:39;;;9462:3;9455:52;9449:63;;;9763:111;9840:28;9862:5;9840:28;;9881:356;;10009:38;10041:5;10009:38;;;10059:88;10140:6;10135:3;10059:88;;;10052:95;;10152:52;10197:6;10192:3;10185:4;10178:5;10174:16;10152:52;;;10216:16;;;;;9989:248;-1:-1;;9989:248;10244:315;;10340:34;10368:5;10340:34;;;10386:60;10439:6;10434:3;10386:60;;;10379:67;;10451:52;10496:6;10491:3;10484:4;10477:5;10473:16;10451:52;;;10524:29;10546:6;10524:29;;;10515:39;;;;10320:239;-1:-1;;;10320:239;10908:170;11013:59;11066:5;11013:59;;11086:364;;11246:67;11310:2;11305:3;11246:67;;;11346:66;11326:87;;11441:2;11432:12;;11232:218;-1:-1;;11232:218;11459:364;;11619:67;11683:2;11678:3;11619:67;;;11719:66;11699:87;;11814:2;11805:12;;11605:218;-1:-1;;11605:218;11832:364;;11992:67;12056:2;12051:3;11992:67;;;12092:66;12072:87;;12187:2;12178:12;;11978:218;-1:-1;;11978:218;12205:364;;12365:67;12429:2;12424:3;12365:67;;;12465:66;12445:87;;12560:2;12551:12;;12351:218;-1:-1;;12351:218;12630:2263;12851:22;;12630:2263;;12777:5;12768:15;;;12879:61;12772:3;12851:22;12879:61;;;12798:148;13026:4;13019:5;13015:16;13009:23;13038:62;13094:4;13089:3;13085:14;13072:11;13038:62;;;12956:150;13193:4;13186:5;13182:16;13176:23;13205:62;13261:4;13256:3;13252:14;13239:11;13205:62;;;13116:157;13354:4;13347:5;13343:16;13337:23;13366:62;13422:4;13417:3;13413:14;13400:11;13366:62;;;13283:151;13518:4;13511:5;13507:16;13501:23;13530:62;13586:4;13581:3;13577:14;13564:11;13530:62;;;13444:154;13682:4;13675:5;13671:16;13665:23;13694:62;13750:4;13745:3;13741:14;13728:11;13694:62;;;13608:154;13838:4;13831:5;13827:16;13821:23;13850:62;13906:4;13901:3;13897:14;13884:11;13850:62;;;13772:146;13994:4;13987:5;13983:16;13977:23;14006:62;14062:4;14057:3;14053:14;14040:11;14006:62;;;13928:146;14163:5;14156;14152:17;14146:24;14176:63;14232:5;14227:3;14223:15;14210:11;14176:63;;;14084:161;14317:5;14310;14306:17;14300:24;14330:63;14386:5;14381:3;14377:15;14364:11;14330:63;;;14255:144;14481:5;14474;14470:17;14464:24;14535:3;14529:4;14525:14;14517:5;14512:3;14508:15;14501:39;14555:66;14616:4;14603:11;14555:66;;;14547:74;;14409:224;14715:5;14708;14704:17;14698:24;14769:3;14763:4;14759:14;14751:5;14746:3;14742:15;14735:39;14789:66;14850:4;14837:11;14789:66;;14900:110;14973:31;14998:5;14973:31;;15144:262;;15288:93;15377:3;15368:6;15288:93;;15413:213;15531:2;15516:18;;15545:71;15520:9;15589:6;15545:71;;15885:324;16031:2;16016:18;;16045:71;16020:9;16089:6;16045:71;;;16127:72;16195:2;16184:9;16180:18;16171:6;16127:72;;16216:324;16362:2;16347:18;;16376:71;16351:9;16420:6;16376:71;;;16458:72;16526:2;16515:9;16511:18;16502:6;16458:72;;16547:201;16659:2;16644:18;;16673:65;16648:9;16711:6;16673:65;;16755:257;16895:2;16880:18;;16909:93;16884:9;16975:6;16909:93;;17019:407;17210:2;17224:47;;;17195:18;;17285:131;17195:18;17285:131;;17433:407;17624:2;17638:47;;;17609:18;;17699:131;17609:18;17699:131;;17847:407;18038:2;18052:47;;;18023:18;;18113:131;18023:18;18113:131;;18261:407;18452:2;18466:47;;;18437:18;;18527:131;18437:18;18527:131;;18675:353;18839:2;18853:47;;;18824:18;;18914:104;18824:18;19004:6;18914:104;;19035:651;19269:2;19283:47;;;19254:18;;19344:104;19254:18;19434:6;19344:104;;;19336:112;;19459:72;19527:2;19516:9;19512:18;19503:6;19459:72;;;19579:9;19573:4;19569:20;19564:2;19553:9;19549:18;19542:48;19604:72;19671:4;19662:6;19604:72;;19693:213;19811:2;19796:18;;19825:71;19800:9;19869:6;19825:71;;19913:324;20059:2;20044:18;;20073:71;20048:9;20117:6;20073:71;;20244:256;20306:2;20300:9;20332:17;;;20407:18;20392:34;;20428:22;;;20389:62;20386:2;;;20464:1;20461;20454:12;20386:2;20480;20473:22;20284:216;;-1:-1;20284:216;20507:254;;20646:18;20638:6;20635:30;20632:2;;;20678:1;20675;20668:12;20632:2;-1:-1;20751:4;20722;20699:17;;;;-1:-1;;20695:33;20741:15;;20569:192;21033:87;21103:12;;21087:33;21226:152;21318:19;;;21367:4;21358:14;;21311:67;21558:144;21693:3;21671:31;-1:-1;21671:31;21882:105;;21951:31;21976:5;21951:31;;22114:92;22187:13;22180:21;;22163:43;22213:128;-1:-1;;;;;22282:54;;22265:76;22348:79;22417:5;22400:27;23072:88;23150:4;23139:16;;23122:38;23167:165;;23268:59;23321:5;23268:59;;23484:145;23565:6;23560:3;23555;23542:30;-1:-1;23621:1;23603:16;;23596:27;23535:94;23638:268;23703:1;23710:101;23724:6;23721:1;23718:13;23710:101;;;23791:11;;;23785:18;23772:11;;;23765:39;23746:2;23739:10;23710:101;;;23826:6;23823:1;23820:13;23817:2;;;23891:1;23882:6;23877:3;23873:16;23866:27;23817:2;23687:219;;;;;23914:97;24002:2;23982:14;-1:-1;;23978:28;;23962:49

bzzr://e0a9c6855da98757f32d5d52e2034b7610d5dece0abef12307a86345321aaa85