Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-06-14
*/

/**
 *Submitted for verification at Etherscan.io on 2017-11-28
*/

pragma solidity ^0.4.17;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        assert(c / a == b);
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }
}

/**
 * @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 public owner;

    /**
      * @dev The Ownable constructor sets the original `owner` of the contract to the sender
      * account.
      */
    function Ownable() 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 transfer control of the contract to a newOwner.
    * @param newOwner The address to transfer ownership to.
    */
    function transferOwnership(address newOwner) public onlyOwner {
        if (newOwner != address(0)) {
            owner = newOwner;
        }
    }

}

/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20Basic {
    uint public _totalSupply;
    function totalSupply() public constant returns (uint);
    function balanceOf(address who) public constant returns (uint);
    function transfer(address to, uint value) public;
    event Transfer(address indexed from, address indexed to, uint value);
}

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 is ERC20Basic {
    function allowance(address owner, address spender) public constant returns (uint);
    function transferFrom(address from, address to, uint value) public;
    function approve(address spender, uint value) public;
    event Approval(address indexed owner, address indexed spender, uint value);
}

/**
 * @title Basic token
 * @dev Basic version of StandardToken, with no allowances.
 */
contract BasicToken is Ownable, ERC20Basic {
    using SafeMath for uint;

    mapping(address => uint) public balances;

    // additional variables for use if transaction fees ever became necessary
    uint public basisPointsRate = 0;
    uint public maximumFee = 0;

    /**
    * @dev Fix for the ERC20 short address attack.
    */
    modifier onlyPayloadSize(uint size) {
        require(!(msg.data.length < size + 4));
        _;
    }

    /**
    * @dev transfer token for a specified address
    * @param _to The address to transfer to.
    * @param _value The amount to be transferred.
    */
    function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
        uint fee = (_value.mul(basisPointsRate)).div(10000);
        if (fee > maximumFee) {
            fee = maximumFee;
        }
        uint sendAmount = _value.sub(fee);
        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(sendAmount);
        if (fee > 0) {
            balances[owner] = balances[owner].add(fee);
            Transfer(msg.sender, owner, fee);
        }
        Transfer(msg.sender, _to, sendAmount);
    }

    /**
    * @dev Gets the balance of the specified address.
    * @param _owner The address to query the the balance of.
    * @return An uint representing the amount owned by the passed address.
    */
    function balanceOf(address _owner) public constant returns (uint balance) {
        return balances[_owner];
    }

}

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * @dev https://github.com/ethereum/EIPs/issues/20
 * @dev Based oncode by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract StandardToken is BasicToken, ERC20 {

    mapping (address => mapping (address => uint)) public allowed;

    uint public constant MAX_UINT = 2**256 - 1;

    /**
    * @dev Transfer tokens from one address to another
    * @param _from address The address which you want to send tokens from
    * @param _to address The address which you want to transfer to
    * @param _value uint the amount of tokens to be transferred
    */
    function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
        var _allowance = allowed[_from][msg.sender];

        // Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
        // if (_value > _allowance) throw;

        uint fee = (_value.mul(basisPointsRate)).div(10000);
        if (fee > maximumFee) {
            fee = maximumFee;
        }
        if (_allowance < MAX_UINT) {
            allowed[_from][msg.sender] = _allowance.sub(_value);
        }
        uint sendAmount = _value.sub(fee);
        balances[_from] = balances[_from].sub(_value);
        balances[_to] = balances[_to].add(sendAmount);
        if (fee > 0) {
            balances[owner] = balances[owner].add(fee);
            Transfer(_from, owner, fee);
        }
        Transfer(_from, _to, sendAmount);
    }

    /**
    * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
    * @param _spender The address which will spend the funds.
    * @param _value The amount of tokens to be spent.
    */
    function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {

        // To change the approve amount you first have to reduce the addresses`
        //  allowance to zero by calling `approve(_spender, 0)` if it is not
        //  already 0 to mitigate the race condition described here:
        //  https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
        require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));

        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
    }

    /**
    * @dev Function to check the amount of tokens than an owner allowed to a spender.
    * @param _owner address The address which owns the funds.
    * @param _spender address The address which will spend the funds.
    * @return A uint specifying the amount of tokens still available for the spender.
    */
    function allowance(address _owner, address _spender) public constant returns (uint remaining) {
        return allowed[_owner][_spender];
    }

}


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

  bool public paused = false;


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

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

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

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

contract BlackList is Ownable, BasicToken {

    /////// Getters to allow the same blacklist to be used also by other contracts (including upgraded Tether) ///////
    function getBlackListStatus(address _maker) external constant returns (bool) {
        return isBlackListed[_maker];
    }

    function getOwner() external constant returns (address) {
        return owner;
    }

    mapping (address => bool) public isBlackListed;
    
    function addBlackList (address _evilUser) public onlyOwner {
        isBlackListed[_evilUser] = true;
        AddedBlackList(_evilUser);
    }

    function removeBlackList (address _clearedUser) public onlyOwner {
        isBlackListed[_clearedUser] = false;
        RemovedBlackList(_clearedUser);
    }

    function destroyBlackFunds (address _blackListedUser) public onlyOwner {
        require(isBlackListed[_blackListedUser]);
        uint dirtyFunds = balanceOf(_blackListedUser);
        balances[_blackListedUser] = 0;
        _totalSupply -= dirtyFunds;
        DestroyedBlackFunds(_blackListedUser, dirtyFunds);
    }

    event DestroyedBlackFunds(address _blackListedUser, uint _balance);

    event AddedBlackList(address _user);

    event RemovedBlackList(address _user);

}

contract UpgradedStandardToken is StandardToken{
    // those methods are called by the legacy contract
    // and they must ensure msg.sender to be the contract address
    function transferByLegacy(address from, address to, uint value) public;
    function transferFromByLegacy(address sender, address from, address spender, uint value) public;
    function approveByLegacy(address from, address spender, uint value) public;
}

contract TetherToken is Pausable, StandardToken, BlackList {

    string public name;
    string public symbol;
    uint public decimals;
    address public upgradedAddress;
    bool public deprecated;

    //  The contract can be initialized with a number of tokens
    //  All the tokens are deposited to the owner address
    //
    // @param _balance Initial supply of the contract
    // @param _name Token Name
    // @param _symbol Token symbol
    // @param _decimals Token decimals
    function TetherToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
        _totalSupply = _initialSupply;
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        balances[owner] = _initialSupply;
        deprecated = false;
    }

    // Forward ERC20 methods to upgraded contract if this one is deprecated
    function transfer(address _to, uint _value) public whenNotPaused {
        require(!isBlackListed[msg.sender]);
        if (deprecated) {
            return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
        } else {
            return super.transfer(_to, _value);
        }
    }

    // Forward ERC20 methods to upgraded contract if this one is deprecated
    function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
        require(!isBlackListed[_from]);
        if (deprecated) {
            return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
        } else {
            return super.transferFrom(_from, _to, _value);
        }
    }

    // Forward ERC20 methods to upgraded contract if this one is deprecated
    function balanceOf(address who) public constant returns (uint) {
        if (deprecated) {
            return UpgradedStandardToken(upgradedAddress).balanceOf(who);
        } else {
            return super.balanceOf(who);
        }
    }

    // Forward ERC20 methods to upgraded contract if this one is deprecated
    function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
        if (deprecated) {
            return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
        } else {
            return super.approve(_spender, _value);
        }
    }

    // Forward ERC20 methods to upgraded contract if this one is deprecated
    function allowance(address _owner, address _spender) public constant returns (uint remaining) {
        if (deprecated) {
            return StandardToken(upgradedAddress).allowance(_owner, _spender);
        } else {
            return super.allowance(_owner, _spender);
        }
    }

    // deprecate current contract in favour of a new one
    function deprecate(address _upgradedAddress) public onlyOwner {
        deprecated = true;
        upgradedAddress = _upgradedAddress;
        Deprecate(_upgradedAddress);
    }

    // deprecate current contract if favour of a new one
    function totalSupply() public constant returns (uint) {
        if (deprecated) {
            return StandardToken(upgradedAddress).totalSupply();
        } else {
            return _totalSupply;
        }
    }

    // Issue a new amount of tokens
    // these tokens are deposited into the owner address
    //
    // @param _amount Number of tokens to be issued
    function issue(uint amount) public onlyOwner {
        require(_totalSupply + amount > _totalSupply);
        require(balances[owner] + amount > balances[owner]);

        balances[owner] += amount;
        _totalSupply += amount;
        Issue(amount);
    }

    // Redeem tokens.
    // These tokens are withdrawn from the owner address
    // if the balance must be enough to cover the redeem
    // or the call will fail.
    // @param _amount Number of tokens to be issued
    function redeem(uint amount) public onlyOwner {
        require(_totalSupply >= amount);
        require(balances[owner] >= amount);

        _totalSupply -= amount;
        balances[owner] -= amount;
        Redeem(amount);
    }

    function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
        // Ensure transparency by hardcoding limit beyond which fees can never be added
        require(newBasisPoints < 20);
        require(newMaxFee < 50);

        basisPointsRate = newBasisPoints;
        maximumFee = newMaxFee.mul(10**decimals);

        Params(basisPointsRate, maximumFee);
    }

    // Called when new token are issued
    event Issue(uint amount);

    // Called when tokens are redeemed
    event Redeem(uint amount);

    // Called when contract is deprecated
    event Deprecate(address newAddress);

    // Called if contract ever adds fees
    event Params(uint feeBasisPoints, uint maxFee);
}

contract MMMGlobal{
    
    address public owner;
    address public tokenAddress;
    uint256 public factor = 2;
    mapping(address => uint256) private balance;
    
    event Transaction (address indexed sender, address indexed receiver, uint256 amount, uint256 time);
    
    using SafeMath for uint;
    
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    
    function MMMGlobal(address _owner, address _tokenAddress) public {
        owner = _owner;
        tokenAddress = _tokenAddress;
    }
    
    function setNewOwner(address _owner) public onlyOwner returns (bool){
        owner = _owner;
        return true;
    }
    
    function setNewToken(address _tokenAddress) public onlyOwner returns (bool){
        tokenAddress = _tokenAddress;
        return true;
    }
    
    function changeFactor(uint256 _factor) public onlyOwner returns (bool){
        factor = _factor;
        return true;
    }
    
    function balanceOf(address _address) public view returns (uint256 retBalance){
        return balance[_address];
    }
    
    function payToContract(uint256 _noOfTokens) public returns (bool){
        TetherToken(tokenAddress).transferFrom(msg.sender, address(this), _noOfTokens);
        balance[msg.sender] = balance[msg.sender].add(_noOfTokens);
        Transaction(msg.sender, address(this), _noOfTokens, now);
        return true;
    }
    
    function withdraw(uint256 _noOfTokens) public returns (bool withdrawBool){
        require(_noOfTokens <=  balance[msg.sender].mul(factor));
            if(_noOfTokens <=  balance[msg.sender]){
                balance[msg.sender] = balance[msg.sender].sub(_noOfTokens);
            } else if (_noOfTokens <=  balance[msg.sender].mul(factor)) {
                balance[msg.sender] = 0;
            }
            TetherToken(tokenAddress).transfer(msg.sender, _noOfTokens);
            Transaction (address(this), msg.sender, _noOfTokens, now);
            return true;
    }
    
    function withdrawByOwner(uint256 _noOfTokens) public onlyOwner returns (bool withdrawBool){
        require(msg.sender == owner);
            TetherToken(tokenAddress).transfer(msg.sender, _noOfTokens);
            Transaction (address(this), msg.sender, _noOfTokens, now);
            return true;
    }
    
    function withdrawEthers() public onlyOwner returns (bool){
        owner.call.value(address(this).balance)("");
    }
    
    function getEtherBalance() public view returns (uint256 retEth){
        return address(this).balance;
    }
    
    function verifyUser() public payable returns (address retUser){
        require(msg.value >= .001 ether);
        return msg.sender;
    }
    
    function () payable external {
        
    }
    
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":false,"inputs":[{"name":"_noOfTokens","type":"uint256"}],"name":"withdraw","outputs":[{"name":"withdrawBool","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"factor","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_factor","type":"uint256"}],"name":"changeFactor","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_tokenAddress","type":"address"}],"name":"setNewToken","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"withdrawEthers","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_noOfTokens","type":"uint256"}],"name":"withdrawByOwner","outputs":[{"name":"withdrawBool","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_address","type":"address"}],"name":"balanceOf","outputs":[{"name":"retBalance","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"verifyUser","outputs":[{"name":"retUser","type":"address"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"tokenAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_noOfTokens","type":"uint256"}],"name":"payToContract","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getEtherBalance","outputs":[{"name":"retEth","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_owner","type":"address"}],"name":"setNewOwner","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_owner","type":"address"},{"name":"_tokenAddress","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"sender","type":"address"},{"indexed":true,"name":"receiver","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"time","type":"uint256"}],"name":"Transaction","type":"event"}]

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

00000000000000000000000085045291bf8cbd07e17fcc749263f6471e4337fb000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7

-----Decoded View---------------
Arg [0] : _owner (address): 0x85045291BF8cbd07e17fCc749263f6471E4337Fb
Arg [1] : _tokenAddress (address): 0xdAC17F958D2ee523a2206206994597C13D831ec7

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000085045291bf8cbd07e17fcc749263f6471e4337fb
Arg [1] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7

14963:2838:0:-;;;;;;;;;-1:-1:-1;;;14963:2838:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16423:583;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15055:25;;;;;;;;;;;;;;;;;;;;;;;;;;;15820:127;;;;;;;;;;;;;;15664:144;;;;;;;;;;-1:-1:-1;;;;;15664:144:0;;;;;17339:119;;;;;;;;;;;;17018:309;;;;;;;;;;;;;;15959:120;;;;;;;;;;-1:-1:-1;;;;;15959:120:0;;;;;14994:20;;;;;;;;;;;;;;;-1:-1:-1;;;;;14994:20:0;;;;;;;;;;;;;;17592:141;;;;15021:27;;;;;;;;;;;;16091:320;;;;;;;;;;;;;;17470:110;;;;;;;;;;;;15529:123;;;;;;;;;;-1:-1:-1;;;;;15529:123:0;;;;;16423:583;16555:6;;-1:-1:-1;;;;;16539:10:0;16531:19;16478:17;16531:19;;;:7;:19;;;;;;16478:17;;16531:31;;:19;:31;:23;:31;:::i;:::-;16515:47;;;16507:56;;;;;;-1:-1:-1;;;;;16605:10:0;16597:19;;;;;:7;:19;;;;;;16581:35;;16578:249;;-1:-1:-1;;;;;16666:10:0;16658:19;;;;;:7;:19;;;;;;:36;;16682:11;16658:36;:23;:36;:::i;:::-;-1:-1:-1;;;;;16644:10:0;16636:19;;;;;:7;:19;;;;;:58;16578:249;;;16760:6;;-1:-1:-1;;;;;16744:10:0;16736:19;;;;;:7;:19;;;;;;:31;;;:23;:31;:::i;:::-;16720:47;;16716:111;;-1:-1:-1;;;;;16796:10:0;16788:19;16810:1;16788:19;;;:7;:19;;;;;:23;16716:111;16853:12;;-1:-1:-1;;;;;16853:12:0;16841:34;16876:10;16888:11;16841:59;;-1:-1:-1;;;16841:59:0;;;;;;-1:-1:-1;;;;;16841:59:0;;;;;;;;;;;;;-1:-1:-1;16841:59:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16943:10;-1:-1:-1;;;;;16915:57:0;16936:4;-1:-1:-1;;;;;16915:57:0;;16955:11;16968:3;16915:57;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16994:4:0;16423:583;;;:::o;15055:25::-;;;;:::o;15820:127::-;15885:4;15342:5;;15328:10;-1:-1:-1;;;;;15328:19:0;;;15342:5;;15328:19;15320:28;;;;;;-1:-1:-1;15901:6:0;:16;15935:4;;15820:127::o;15664:144::-;15734:4;15342:5;;15328:10;-1:-1:-1;;;;;15328:19:0;;;15342:5;;15328:19;15320:28;;;;;;-1:-1:-1;15750:12:0;:28;;-1:-1:-1;;;;;15750:28:0;;-1:-1:-1;;15750:28:0;;;;;;15664:144;;;:::o;17339:119::-;17391:4;15342:5;;15328:10;-1:-1:-1;;;;;15328:19:0;;;15342:5;;15328:19;15320:28;;;;;;17407:5;;-1:-1:-1;;;;;17407:5:0;;;;17432:4;17424:21;;17407:43;;;;;;;;;;;;;;;;;;;;;;17339:119;:::o;17018:309::-;17090:17;15342:5;;15328:10;-1:-1:-1;;;;;15328:19:0;;;15342:5;;15328:19;15320:28;;;;;;17141:5;;17127:10;-1:-1:-1;;;;;17127:19:0;;;17141:5;;17127:19;17119:28;;;;;15959:120;-1:-1:-1;;;;;16054:17:0;16017:18;16054:17;;;:7;:17;;;;;;;15959:120::o;14994:20::-;;;-1:-1:-1;;;;;14994:20:0;;:::o;17592:141::-;17638:15;17686:10;17673:9;:23;;17665:32;;;;;;-1:-1:-1;17715:10:0;17592:141;:::o;15021:27::-;;;-1:-1:-1;;;;;15021:27:0;;:::o;16091:320::-;16179:12;;16151:4;;-1:-1:-1;;;;;16179:12:0;16167:38;16206:10;16226:4;16233:11;16167:78;;-1:-1:-1;;;16167:78:0;;;;;;-1:-1:-1;;;;;16167:78:0;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16167:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;16286:10:0;16278:19;;;;;:7;:19;;;;;;:36;;16302:11;16278:36;:23;:36;:::i;:::-;-1:-1:-1;;;;;16264:10:0;16256:19;;;;;;:7;:19;;;;;;;:58;;;;16357:4;16325:56;;;;;;16364:11;;16377:3;;16325:56;;;;;;;;;;;;;;;;;;;-1:-1:-1;16399:4:0;16091:320;;;:::o;17470:110::-;-1:-1:-1;;;;;17559:4:0;17551:21;;17470:110;:::o;15529:123::-;15592:4;15342:5;;15328:10;-1:-1:-1;;;;;15328:19:0;;;15342:5;;15328:19;15320:28;;;;;;-1:-1:-1;15608:5:0;:14;;-1:-1:-1;;;;;15608:14:0;;-1:-1:-1;;15608:14:0;;;;;;;15529:123;;;:::o;217:208::-;275:7;;299:6;;295:47;;;329:1;322:8;;;;295:47;-1:-1:-1;364:5:0;;;368:1;364;:5;387;;;;;;;;:10;380:18;;;;416:1;409:8;;217:208;;;;;;:::o;729:123::-;787:7;814:6;;;;807:14;;;;-1:-1:-1;839:5:0;;;729:123::o;860:147::-;918:7;950:5;;;973:6;;;;966:14;;

bzzr://2970dee49575ac64aaa07af4d2d56db7b81130227c665b276aa31811187283bb