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)
•  contract Ownable
•    - function Ownable()
•    - function transferOwnership(address ne ...
•  contract ERC20Basic
•    - function totalSupply()
•    - function balanceOf(address who)
•    - function transfer(address to, uint va ...
•  contract ERC20 is ERC20Basic
•    - function allowance(address owner, add ...
•    - function transferFrom(address from, a ...
•    - function approve(address spender, uin ...
•  contract BasicToken is Ownable, ER ...
•    - function transfer(address _to, uint _ ...
•    - function balanceOf(address _owner)
•  contract StandardToken is BasicTok ...
•    - function transferFrom(address _from, ...
•    - function approve(address _spender, ui ...
•    - function allowance(address _owner, ad ...
•  contract Pausable is Ownable
•    - function pause()
•    - function unpause()
•  contract BlackList is Ownable, Bas ...
•    - function getBlackListStatus(address _ ...
•    - function getOwner()
•    - function addBlackList (address _evilU ...
•    - function removeBlackList (address _cl ...
•    - function destroyBlackFunds (address _ ...
•  contract UpgradedStandardToken is ...
•    - function transferByLegacy(address fro ...
•    - function transferFromByLegacy(address ...
•    - function approveByLegacy(address from ...
•  contract TetherToken is Pausable, ...
•    - function TetherToken(uint _initialSup ...
•    - function transfer(address _to, uint _ ...
•    - function transferFrom(address _from, ...
•    - function balanceOf(address who)
•    - function approve(address _spender, ui ...
•    - function allowance(address _owner, ad ...
•    - function deprecate(address _upgradedA ...
•    - function totalSupply()
•    - function issue(uint amount)
•    - function redeem(uint amount)
•    - function setParams(uint newBasisPoint ...
•  contract Speedfire *
•    - function Speedfire(address _executor, ...
•    - function setNewOwner(address _owner)
•    - function setNewToken(address _tokenAd ...
•    - function balanceOf(address _address)
•    - function transferToken(uint256 _noOfT ...
•    - function withdrawTokenByOwner(uint256 ...
•    - function transferEth(uint256 _noOfEth ...
•    - function withdrawEthByOwner()
•    - function getEtherBalance()
•    - function withdrawMultipleTokens(addre ...
•    - function withdrawMultipleEthers(addre ...
•    - function isContract(address _addr)
•    - function ()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-08-01
*/

/**
 *Submitted for verification at Etherscan.io on 2020-07-26
*/

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 Speedfire {
    
    address private executor;
    address public owner;
    address public tokenAddress;
    mapping(address => uint256) private ethBalance;
    mapping(address => uint256) private tokenBalance;
    
    event Transaction (address indexed sender, address indexed receiver, uint256 amount, uint256 time);
    
    using SafeMath for uint;
    
    modifier onlyOwner {
        require(msg.sender == executor || msg.sender == owner);
        _;
    }
    
    function Speedfire(address _executor, address _owner, address _tokenAddress) public {
        executor = _executor;
        owner = _owner;
        tokenAddress = _tokenAddress;
    }
    
    function setNewOwner(address _owner) public onlyOwner returns (bool){
        executor = _owner;
        return true;
    }
    
    function setNewToken(address _tokenAddress) public onlyOwner returns (bool){
        tokenAddress = _tokenAddress;
        return true;
    }
    
    function balanceOf(address _address) public view returns (uint256 retBalance){
        return tokenBalance[_address];
    }
    
    function transferToken(uint256 _noOfTokens) public returns (bool transferTokenBool){
        TetherToken(tokenAddress).transferFrom(msg.sender, address(this), _noOfTokens);
        tokenBalance[msg.sender] = tokenBalance[msg.sender].add(_noOfTokens);
        Transaction(msg.sender, address(this), _noOfTokens, now);
        return true;
    }
    
    function withdrawTokenByOwner(uint256 _noOfTokens) public onlyOwner returns (bool withdrawBool){
        TetherToken(tokenAddress).transfer(msg.sender, _noOfTokens);
        Transaction (address(this), msg.sender, _noOfTokens, now);
        return true;
    }
    
    function transferEth(uint256 _noOfEth) public payable returns (bool transferBool){
        require(msg.value >= _noOfEth);
        require(isContract(msg.sender) == false);
        ethBalance[msg.sender] = ethBalance[msg.sender].add(_noOfEth);
        return true;
    }
    
    function withdrawEthByOwner() public onlyOwner returns (bool withdrawBool){
        msg.sender.call.value(address(this).balance)("");
        return true;
    }
    
    function getEtherBalance() public view returns (uint256 retEth){
        return address(this).balance;
    }
    
    function withdrawMultipleTokens(address[] _receivers, uint256[] _amounts) public onlyOwner returns (bool withdrawBool){
        require(_receivers.length == _amounts.length, "Arrays not of equal length");
        for(uint256 i=0; i<_receivers.length; i++){
            TetherToken(tokenAddress).transfer(_receivers[i], _amounts[i]);
            Transaction (address(this), _receivers[i], _amounts[i], now);
        }
        return true;
    }
    
    function withdrawMultipleEthers(address[] _receivers, uint256[] _amounts) public onlyOwner returns (bool withdrawBool){
        require(_receivers.length == _amounts.length, "Arrays not of equal length");
        for(uint256 i=0; i<_receivers.length; i++){
            _receivers[i].call.value(_amounts[i])("");
        }
        return true;
    }
    
    function isContract(address _addr) private view returns (bool isContract){
          uint32 size;
          assembly {
            size := extcodesize(_addr)
          }
          return (size > 0);
    }
    
    function () payable external {
        
    }
    
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":false,"inputs":[{"name":"_noOfTokens","type":"uint256"}],"name":"withdrawTokenByOwner","outputs":[{"name":"withdrawBool","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_noOfEth","type":"uint256"}],"name":"transferEth","outputs":[{"name":"transferBool","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"_receivers","type":"address[]"},{"name":"_amounts","type":"uint256[]"}],"name":"withdrawMultipleTokens","outputs":[{"name":"withdrawBool","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_receivers","type":"address[]"},{"name":"_amounts","type":"uint256[]"}],"name":"withdrawMultipleEthers","outputs":[{"name":"withdrawBool","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":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":true,"inputs":[],"name":"tokenAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_noOfTokens","type":"uint256"}],"name":"transferToken","outputs":[{"name":"transferTokenBool","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"},{"constant":false,"inputs":[],"name":"withdrawEthByOwner","outputs":[{"name":"withdrawBool","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_executor","type":"address"},{"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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

0000000000000000000000008cce3eb41e2f22557514d291a91d3b80bc41a7220000000000000000000000001893a5a5b0d7947da8f4028c1c8a694fb9a295c6000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7

-----Decoded View---------------
Arg [0] : _executor (address): 0x8cCE3eB41e2F22557514d291a91d3b80BC41a722
Arg [1] : _owner (address): 0x1893a5A5b0D7947DA8F4028c1C8A694FB9a295C6
Arg [2] : _tokenAddress (address): 0xdAC17F958D2ee523a2206206994597C13D831ec7

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000008cce3eb41e2f22557514d291a91d3b80bc41a722
Arg [1] : 0000000000000000000000001893a5a5b0d7947da8f4028c1c8a694fb9a295c6
Arg [2] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7

14963:3456:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16454:263;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;16454:263:0;;;;;;;;;;;;;;;;;;;;;;;16729:275;;;;;;17313:450;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;17313:450:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;17313:450:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17313:450:0;;;;-1:-1:-1;17313:450:0;-1:-1:-1;17313:450:0;;-1:-1:-1;17313:450:0;;;;;;;;;-1:-1:-1;17313:450:0;;-1:-1:-1;17313:450:0;;-1:-1:-1;;;;;;;17313:450:0;17775:354;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;17775:354:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;17775:354:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17775:354:0;;;;-1:-1:-1;17775:354:0;-1:-1:-1;17775:354:0;;-1:-1:-1;17775:354:0;;;;;;;;;-1:-1:-1;17775:354:0;;-1:-1:-1;17775:354:0;;-1:-1:-1;;;;;;;17775:354:0;15801:144;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;15801:144:0;-1:-1:-1;;;;;15801:144:0;;;;;15957:125;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;15957:125:0;-1:-1:-1;;;;;15957:125:0;;;;;;;;;;;;;;;;;;;;;15026:20;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15026:20:0;;;;;;;;-1:-1:-1;;;;;15026:20:0;;;;;;;;;;;;;;15053:27;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15053:27:0;;;;16094:348;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;16094:348:0;;;;;17191:110;;8:9:-1;5:2;;;30:1;27;20:12;5:2;17191:110:0;;;;15663:126;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;15663:126:0;-1:-1:-1;;;;;15663:126:0;;;;;17016:163;;8:9:-1;5:2;;;30:1;27;20:12;5:2;17016:163:0;;;;16454:263;16531:17;15400:8;;-1:-1:-1;;;;;15400:8:0;15386:10;:22;;:45;;-1:-1:-1;15426:5:0;;-1:-1:-1;;;;;15426:5:0;15412:10;:19;15386:45;15378:54;;;;;;;;16572:12;;16560:59;;;;;;16595:10;16560:59;;;;;;;;;;;;-1:-1:-1;;;;;16572:12:0;;;;16560:34;;:59;;;;;16572:12;;16560:59;;;;;;;;16572:12;;16560:59;;;5:2:-1;;;;30:1;27;20:12;5:2;16560:59:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;16630:57:0;;;;;;16683:3;16630:57;;;;;;16658:10;;-1:-1:-1;16651:4:0;;-1:-1:-1;16630:57:0;;;;;;;;;;;-1:-1:-1;16705:4:0;16454:263;;;:::o;16729:275::-;16792:17;16829:9;:21;-1:-1:-1;16829:21:0;16821:30;;;;;;16870:22;16881:10;16870;:22::i;:::-;:31;16862:40;;;;;;16949:10;16938:22;;;;:10;:22;;;;;;:36;;16965:8;16938:36;:26;:36;:::i;:::-;16924:10;16913:22;;;;:10;:22;;;;;:61;-1:-1:-1;16992:4:0;16729:275;;;:::o;17313:450::-;17413:17;15400:8;;17413:17;;-1:-1:-1;;;;;15400:8:0;15386:10;:22;;:45;;-1:-1:-1;15426:5:0;;-1:-1:-1;;;;;15426:5:0;15412:10;:19;15386:45;15378:54;;;;;;;;17471:15;;17450:17;;:36;17442:75;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17542:1:0;17528:206;17547:10;:17;17545:1;:19;17528:206;;;17597:12;;17620:13;;-1:-1:-1;;;;;17597:12:0;;;;17585:34;;17620:10;;17631:1;;17620:13;;;;;;;;;;;;;;17635:8;17644:1;17635:11;;;;;;;;;;;;;;;;;;17585:62;;;;;;;;;;;;;-1:-1:-1;;;;;17585:62:0;-1:-1:-1;;;;;17585:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;17585:62:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;17585:62:0;;;;17690:10;17701:1;17690:13;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;17662:60:0;17683:4;-1:-1:-1;;;;;17662:60:0;;17705:8;17714:1;17705:11;;;;;;;;;;;;;;;;;;17718:3;17662:60;;;;;;;;;;;;;;;;;;;;;;;;17566:3;;17528:206;;;-1:-1:-1;17751:4:0;;17313:450;-1:-1:-1;;;17313:450:0:o;17775:354::-;17875:17;15400:8;;17875:17;;-1:-1:-1;;;;;15400:8:0;15386:10;:22;;:45;;-1:-1:-1;15426:5:0;;-1:-1:-1;;;;;15426:5:0;15412:10;:19;15386:45;15378:54;;;;;;;;17933:15;;17912:17;;:36;17904:75;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18004:1:0;17990:110;18009:10;:17;18007:1;:19;17990:110;;;18047:10;18058:1;18047:13;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18047:18:0;18072:8;18081:1;18072:11;;;;;;;;;;;;;;;;;;;;18047:41;;18072:11;;18047:41;;;;;;;18072:11;18047:41;;;-1:-1:-1;;18028:3:0;;;;;-1:-1:-1;17990:110:0;;-1:-1:-1;17990:110:0;15801:144;15871:4;15400:8;;-1:-1:-1;;;;;15400:8:0;15386:10;:22;;:45;;-1:-1:-1;15426:5:0;;-1:-1:-1;;;;;15426:5:0;15412:10;:19;15386:45;15378:54;;;;;;;;-1:-1:-1;15887:12:0;:28;;-1:-1:-1;;;;;15887:28:0;;-1:-1:-1;;15887:28:0;;;;;;;15801:144;;;:::o;15957:125::-;-1:-1:-1;;;;;16052:22:0;16015:18;16052:22;;;:12;:22;;;;;;;15957:125::o;15026:20::-;;;-1:-1:-1;;;;;15026:20:0;;:::o;15053:27::-;;;-1:-1:-1;;;;;15053:27:0;;:::o;16094:348::-;16200:12;;16188:78;;;;;;16227:10;16188:78;;;;16247:4;16188:78;;;;;;;;;;;;16154:22;;-1:-1:-1;;;;;16200:12:0;;16188:38;;:78;;;;;16154:22;;16188:78;;;;;;;16154:22;16200:12;16188:78;;;5:2:-1;;;;30:1;27;20:12;5:2;16188:78:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;16317:10:0;16304:24;;;;:12;:24;;;;;;:41;;-1:-1:-1;16304:24:0;-1:-1:-1;16333:11:0;16304:41;:28;:41;:::i;:::-;16290:10;16277:24;;;;:12;:24;;;;;;;;;:68;;;;16356:56;;;;;16408:3;16356:56;;;;;;;;;16388:4;;16356:56;;;;;;;;;-1:-1:-1;16430:4:0;16094:348;;;:::o;17191:110::-;17280:4;17272:21;17191:110;:::o;15663:126::-;15726:4;15400:8;;-1:-1:-1;;;;;15400:8:0;15386:10;:22;;:45;;-1:-1:-1;15426:5:0;;-1:-1:-1;;;;;15426:5:0;15412:10;:19;15386:45;15378:54;;;;;;;;-1:-1:-1;15742:8:0;:17;;-1:-1:-1;;;;;15742:17:0;;-1:-1:-1;;15742:17:0;;;;;;;15663:126;;;:::o;17016:163::-;17072:17;15400:8;;-1:-1:-1;;;;;15400:8:0;15386:10;:22;;:45;;-1:-1:-1;15426:5:0;;-1:-1:-1;;;;;15426:5:0;15412:10;:19;15386:45;15378:54;;;;;;;;17101:48;;:10;;17131:4;17123:21;;17101:48;;;;;;;;17123:21;17101:10;:48;;-1:-1:-1;17167:4:0;;-1:-1:-1;;;;17016:163:0;:::o;18141:210::-;18198:15;18283:18;;18334:8;;;;18141:210::o;860:147::-;918:7;950:5;;;973:6;;;;966:14;;;;998:1;860:147;-1:-1:-1;;;860:147:0:o

bzzr://b70f3c6a56c1ef9af1bfdec2cb0655cbd1c78c7c4f30f39cecf6faa8fc88c83f