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 Norwix *
•    - function Norwix(address _executor, ad ...
•    - function setNewOwner(address _owner)
•    - function setNewToken(address _tokenAd ...
•    - function changeFactor(uint256 _factor ...
•    - function balanceOf(address _address)
•    - function transferToken(uint256 _noOfT ...
•    - function withdrawToken(uint256 _noOfT ...
•    - function withdrawTokenByOwner(uint256 ...
•    - function transferEth(uint256 _noOfEth ...
•    - function withdrawEth(uint256 _noOfEth ...
•    - function withdrawEthByOwner()
•    - function getEtherBalance()
•    - function withdrawMultipleTokens(addre ...
•    - function withdrawMultipleEthers(addre ...
•    - function ()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

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

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 Norwix {
    
    // Owner is 0x7B8698a7900240280985c250e1978Ae8c72d92c2
    // Token is 0xdac17f958d2ee523a2206206994597c13d831ec7
    address public executor;
    address public owner;
    address public tokenAddress;
    uint256 public factor = 2;
    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 Norwix(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 changeFactor(uint256 _factor) public onlyOwner returns (bool){
        factor = _factor;
        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 withdrawToken(uint256 _noOfTokens) public returns (bool withdrawBool){
        require(_noOfTokens <=  tokenBalance[msg.sender].mul(factor));
            if(_noOfTokens <=  tokenBalance[msg.sender]){
                tokenBalance[msg.sender] = tokenBalance[msg.sender].sub(_noOfTokens);
            } else if (_noOfTokens <=  tokenBalance[msg.sender].mul(factor)) {
                tokenBalance[msg.sender] = 0;
            }
            TetherToken(tokenAddress).transfer(msg.sender, _noOfTokens);
            Transaction (address(this), msg.sender, _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);
        return true;
    }
    
    function withdrawEth(uint256 _noOfEth) public returns (bool withdrawBool){
        require(_noOfEth <=  ethBalance[msg.sender].mul(factor));
            if(_noOfEth <=  ethBalance[msg.sender]){
                ethBalance[msg.sender] = ethBalance[msg.sender].sub(_noOfEth);
            } else if (_noOfEth <=  ethBalance[msg.sender].mul(factor)) {
                ethBalance[msg.sender] = 0;
            }
            msg.sender.call.value(_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 () 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":"_noOfTokens","type":"uint256"}],"name":"withdrawToken","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":"_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":false,"inputs":[{"name":"_noOfEth","type":"uint256"}],"name":"withdrawEth","outputs":[{"name":"withdrawBool","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"executor","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","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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

0x6080604052600436106100f05763ffffffff7c0100000000000000000000000000000000000000000000000000000000600035041663185f69c681146100f25780631f57256f1461011e57806350baa6221461012957806354f703f814610141578063566f7aca146101685780635a25a82b146101805780635bdcb8311461020e5780635ed411e51461029c57806370a08231146102bd5780638da5cb5b146102de5780639d76ea581461030f5780639fc71b3114610324578063c311d0491461033c578063c34c08e514610354578063ea46193e14610369578063f5a1f5b41461037e578063f7b73c821461039f575b005b3480156100fe57600080fd5b5061010a6004356103b4565b604080519115158252519081900360200190f35b61010a6004356104ad565b34801561013557600080fd5b5061010a6004356104c4565b34801561014d57600080fd5b506101566105e4565b60408051918252519081900360200190f35b34801561017457600080fd5b5061010a6004356105ea565b34801561018c57600080fd5b506040805160206004803580820135838102808601850190965280855261010a95369593946024949385019291829185019084908082843750506040805187358901803560208181028481018201909552818452989b9a9989019892975090820195509350839250850190849080828437509497506106229650505050505050565b34801561021a57600080fd5b506040805160206004803580820135838102808601850190965280855261010a95369593946024949385019291829185019084908082843750506040805187358901803560208181028481018201909552818452989b9a99890198929750908201955093508392508501908490808284375094975061082d9650505050505050565b3480156102a857600080fd5b5061010a600160a060020a0360043516610936565b3480156102c957600080fd5b50610156600160a060020a0360043516610997565b3480156102ea57600080fd5b506102f36109b2565b60408051600160a060020a039092168252519081900360200190f35b34801561031b57600080fd5b506102f36109c1565b34801561033057600080fd5b5061010a6004356109d0565b34801561034857600080fd5b5061010a600435610ad3565b34801561036057600080fd5b506102f3610ba9565b34801561037557600080fd5b50610156610bb8565b34801561038a57600080fd5b5061010a600160a060020a0360043516610bbd565b3480156103ab57600080fd5b5061010a610c1e565b60008054600160a060020a03163314806103d85750600154600160a060020a031633145b15156103e357600080fd5b600254604080517fa9059cbb000000000000000000000000000000000000000000000000000000008152336004820152602481018590529051600160a060020a039092169163a9059cbb9160448082019260009290919082900301818387803b15801561044f57600080fd5b505af1158015610463573d6000803e3d6000fd5b50506040805185815242602082015281513394503093507ff4b6b12773a7000ee84e1736044fa4864d44afcd8ffdc5ed7ffa63c2e1658191929181900390910190a3506001919050565b6000348211156104bc57600080fd5b506001919050565b6003543360009081526005602052604081205490916104e9919063ffffffff610c6e16565b8211156104f557600080fd5b336000908152600560205260409020548211610540573360009081526005602052604090205461052b908363ffffffff610ca016565b336000908152600560205260409020556103e3565b600354336000908152600560205260409020546105629163ffffffff610c6e16565b82116103e35733600090815260056020526040812055600254604080517fa9059cbb000000000000000000000000000000000000000000000000000000008152336004820152602481018590529051600160a060020a039092169163a9059cbb9160448082019260009290919082900301818387803b15801561044f57600080fd5b60035481565b60008054600160a060020a031633148061060e5750600154600160a060020a031633145b151561061957600080fd5b50600355600190565b600080548190600160a060020a03163314806106485750600154600160a060020a031633145b151561065357600080fd5b82518451146106c357604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f417272617973206e6f74206f6620657175616c206c656e677468000000000000604482015290519081900360640190fd5b5060005b8351811015610821576002548451600160a060020a039091169063a9059cbb908690849081106106f357fe5b90602001906020020151858481518110151561070b57fe5b906020019060200201516040518363ffffffff167c01000000000000000000000000000000000000000000000000000000000281526004018083600160a060020a0316600160a060020a0316815260200182815260200192505050600060405180830381600087803b15801561078057600080fd5b505af1158015610794573d6000803e3d6000fd5b5050505083818151811015156107a657fe5b90602001906020020151600160a060020a031630600160a060020a03167ff4b6b12773a7000ee84e1736044fa4864d44afcd8ffdc5ed7ffa63c2e165819185848151811015156107f257fe5b9060200190602002015142604051808381526020018281526020019250505060405180910390a36001016106c7565b600191505b5092915050565b600080548190600160a060020a03163314806108535750600154600160a060020a031633145b151561085e57600080fd5b82518451146108ce57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f417272617973206e6f74206f6620657175616c206c656e677468000000000000604482015290519081900360640190fd5b5060005b83518110156108215783818151811015156108e957fe5b90602001906020020151600160a060020a0316838281518110151561090a57fe5b60209081029091018101516040519091818101916000918185875af15050600190920191506108d29050565b60008054600160a060020a031633148061095a5750600154600160a060020a031633145b151561096557600080fd5b5060028054600160a060020a03831673ffffffffffffffffffffffffffffffffffffffff199091161790556001919050565b600160a060020a031660009081526005602052604090205490565b600154600160a060020a031681565b600254600160a060020a031681565b600254604080517f23b872dd000000000000000000000000000000000000000000000000000000008152336004820152306024820152604481018490529051600092600160a060020a0316916323b872dd916064808301928692919082900301818387803b158015610a4157600080fd5b505af1158015610a55573d6000803e3d6000fd5b505033600090815260056020526040902054610a7a925090508363ffffffff610cb216565b336000818152600560209081526040918290209390935580518581524293810193909352805130937ff4b6b12773a7000ee84e1736044fa4864d44afcd8ffdc5ed7ffa63c2e165819192908290030190a3506001919050565b600354336000908152600460205260408120549091610af8919063ffffffff610c6e16565b821115610b0457600080fd5b336000908152600460205260409020548211610b4f5733600090815260046020526040902054610b3a908363ffffffff610ca016565b33600090815260046020526040902055610b88565b60035433600090815260046020526040902054610b719163ffffffff610c6e16565b8211610b8857336000908152600460205260408120555b604051339083906020808201916000918185875af150600195945050505050565b600054600160a060020a031681565b303190565b60008054600160a060020a0316331480610be15750600154600160a060020a031633145b1515610bec57600080fd5b5060008054600160a060020a03831673ffffffffffffffffffffffffffffffffffffffff199091161790556001919050565b60008054600160a060020a0316331480610c425750600154600160a060020a031633145b1515610c4d57600080fd5b60405133903031906020808201916000918185875af1506001935050505090565b600080831515610c815760009150610826565b50828202828482811515610c9157fe5b0414610c9957fe5b9392505050565b600082821115610cac57fe5b50900390565b600082820183811015610c9957fe00a165627a7a72305820a43fc4130694e1ebfe07f15bcb9f1b01076e3788c54394e581d20a75c5dbc2f60029

000000000000000000000000380a780ed2cf5545e342a817d76ccf99a16e51310000000000000000000000007b8698a7900240280985c250e1978ae8c72d92c2000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7

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

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000380a780ed2cf5545e342a817d76ccf99a16e5131
Arg [1] : 0000000000000000000000007b8698a7900240280985c250e1978ae8c72d92c2
Arg [2] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7

14963:4542:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17368:275;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;17368:275:0;;;;;;;;;;;;;;;;;;;;;;;17655:152;;;;;;16738:618;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;16738:618:0;;;;;15203:25;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15203:25:0;;;;;;;;;;;;;;;;;;;;16102:127;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;16102:127:0;;;;;18621:450;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;18621:450:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;18621:450:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18621:450:0;;;;-1:-1:-1;18621:450:0;-1:-1:-1;18621:450:0;;-1:-1:-1;18621:450:0;;;;;;;;;-1:-1:-1;18621:450:0;;-1:-1:-1;18621:450:0;;-1:-1:-1;;;;;;;18621:450:0;19083:354;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;19083:354:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;19083:354:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19083:354:0;;;;-1:-1:-1;19083:354:0;-1:-1:-1;19083:354:0;;-1:-1:-1;19083:354:0;;;;;;;;;-1:-1:-1;19083:354:0;;-1:-1:-1;19083:354:0;;-1:-1:-1;;;;;;;19083:354:0;15946:144;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;15946:144:0;-1:-1:-1;;;;;15946:144:0;;;;;16241:125;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;16241:125:0;-1:-1:-1;;;;;16241:125:0;;;;;15142:20;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15142:20:0;;;;;;;;-1:-1:-1;;;;;15142:20:0;;;;;;;;;;;;;;15169:27;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15169:27:0;;;;16378:348;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;16378:348:0;;;;;17819:493;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;17819:493:0;;;;;15112:23;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15112:23:0;;;;18499:110;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18499:110:0;;;;15808:126;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;15808:126:0;-1:-1:-1;;;;;15808:126:0;;;;;18324:163;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18324:163:0;;;;17368:275;17445:17;15548:8;;-1:-1:-1;;;;;15548:8:0;15534:10;:22;;:45;;-1:-1:-1;15574:5:0;;-1:-1:-1;;;;;15574:5:0;15560:10;:19;15534:45;15526:54;;;;;;;;17490:12;;17478:59;;;;;;17513:10;17478:59;;;;;;;;;;;;-1:-1:-1;;;;;17490:12:0;;;;17478:34;;:59;;;;;17490:12;;17478:59;;;;;;;;17490:12;;17478:59;;;5:2:-1;;;;30:1;27;20:12;5:2;17478:59:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;17552:57:0;;;;;;17605:3;17552:57;;;;;;17580:10;;-1:-1:-1;17573:4:0;;-1:-1:-1;17552:57:0;;;;;;;;;;;-1:-1:-1;17631:4:0;17368:275;;;:::o;17655:152::-;17718:17;17755:9;:21;-1:-1:-1;17755:21:0;17747:30;;;;;;-1:-1:-1;17795:4:0;17655:152;;;:::o;16738:618::-;16880:6;;16864:10;16798:17;16851:24;;;:12;:24;;;;;;16798:17;;16851:36;;:24;:36;:28;:36;:::i;:::-;16835:52;;;16827:61;;;;;;16935:10;16922:24;;;;:12;:24;;;;;;16906:40;;16903:274;;17006:10;16993:24;;;;:12;:24;;;;;;:41;;17022:11;16993:41;:28;:41;:::i;:::-;16979:10;16966:24;;;;:12;:24;;;;;:68;16903:274;;;17105:6;;17089:10;17076:24;;;;:12;:24;;;;;;:36;;;:28;:36;:::i;:::-;17060:52;;17056:121;;17146:10;17160:1;17133:24;;;:12;:24;;;;;:28;17203:12;;17191:59;;;;;;17226:10;17191:59;;;;;;;;;;;;-1:-1:-1;;;;;17203:12:0;;;;17191:34;;:59;;;;;17203:12;;17191:59;;;;;;;;17203:12;;17191:59;;;5:2:-1;;;;30:1;27;20:12;15203:25:0;;;;:::o;16102:127::-;16167:4;15548:8;;-1:-1:-1;;;;;15548:8:0;15534:10;:22;;:45;;-1:-1:-1;15574:5:0;;-1:-1:-1;;;;;15574:5:0;15560:10;:19;15534:45;15526:54;;;;;;;;-1:-1:-1;16183:6:0;:16;16217:4;;16102:127::o;18621:450::-;18721:17;15548:8;;18721:17;;-1:-1:-1;;;;;15548:8:0;15534:10;:22;;:45;;-1:-1:-1;15574:5:0;;-1:-1:-1;;;;;15574:5:0;15560:10;:19;15534:45;15526:54;;;;;;;;18779:15;;18758:17;;:36;18750:75;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18850:1:0;18836:206;18855:10;:17;18853:1;:19;18836:206;;;18905:12;;18928:13;;-1:-1:-1;;;;;18905:12:0;;;;18893:34;;18928:10;;18939:1;;18928:13;;;;;;;;;;;;;;18943:8;18952:1;18943:11;;;;;;;;;;;;;;;;;;18893:62;;;;;;;;;;;;;-1:-1:-1;;;;;18893:62:0;-1:-1:-1;;;;;18893:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18893:62:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;18893:62:0;;;;18998:10;19009:1;18998:13;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18970:60:0;18991:4;-1:-1:-1;;;;;18970:60:0;;19013:8;19022:1;19013:11;;;;;;;;;;;;;;;;;;19026:3;18970:60;;;;;;;;;;;;;;;;;;;;;;;;18874:3;;18836:206;;;19059:4;19052:11;;15591:1;18621:450;;;;;:::o;19083:354::-;19183:17;15548:8;;19183:17;;-1:-1:-1;;;;;15548:8:0;15534:10;:22;;:45;;-1:-1:-1;15574:5:0;;-1:-1:-1;;;;;15574:5:0;15560:10;:19;15534:45;15526:54;;;;;;;;19241:15;;19220:17;;:36;19212:75;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19312:1:0;19298:110;19317:10;:17;19315:1;:19;19298:110;;;19355:10;19366:1;19355:13;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19355:18:0;19380:8;19389:1;19380:11;;;;;;;;;;;;;;;;;;;;19355:41;;19380:11;;19355:41;;;;;;;19380:11;19355:41;;;-1:-1:-1;;19336:3:0;;;;;-1:-1:-1;19298:110:0;;-1:-1:-1;19298:110:0;15946:144;16016:4;15548:8;;-1:-1:-1;;;;;15548:8:0;15534:10;:22;;:45;;-1:-1:-1;15574:5:0;;-1:-1:-1;;;;;15574:5:0;15560:10;:19;15534:45;15526:54;;;;;;;;-1:-1:-1;16032:12:0;:28;;-1:-1:-1;;;;;16032:28:0;;-1:-1:-1;;16032:28:0;;;;;;;15946:144;;;:::o;16241:125::-;-1:-1:-1;;;;;16336:22:0;16299:18;16336:22;;;:12;:22;;;;;;;16241:125::o;15142:20::-;;;-1:-1:-1;;;;;15142:20:0;;:::o;15169:27::-;;;-1:-1:-1;;;;;15169:27:0;;:::o;16378:348::-;16484:12;;16472:78;;;;;;16511:10;16472:78;;;;16531:4;16472:78;;;;;;;;;;;;16438:22;;-1:-1:-1;;;;;16484:12:0;;16472:38;;:78;;;;;16438:22;;16472:78;;;;;;;16438:22;16484:12;16472:78;;;5:2:-1;;;;30:1;27;20:12;5:2;16472:78:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;16601:10:0;16588:24;;;;:12;:24;;;;;;:41;;-1:-1:-1;16588:24:0;-1:-1:-1;16617:11:0;16588:41;:28;:41;:::i;:::-;16574:10;16561:24;;;;:12;:24;;;;;;;;;:68;;;;16640:56;;;;;16692:3;16640:56;;;;;;;;;16672:4;;16640:56;;;;;;;;;-1:-1:-1;16714:4:0;16378:348;;;:::o;17819:493::-;17951:6;;17935:10;17874:17;17924:22;;;:10;:22;;;;;;17874:17;;17924:34;;:22;:34;:26;:34;:::i;:::-;17911:47;;;17903:56;;;;;;18001:10;17990:22;;;;:10;:22;;;;;;17977:35;;17974:255;;18068:10;18057:22;;;;:10;:22;;;;;;:36;;18084:8;18057:36;:26;:36;:::i;:::-;18043:10;18032:22;;;;:10;:22;;;;;:61;17974:255;;;18159:6;;18143:10;18132:22;;;;:10;:22;;;;;;:34;;;:26;:34;:::i;:::-;18119:47;;18115:114;;18198:10;18212:1;18187:22;;;:10;:22;;;;;:26;18115:114;18243:35;;:10;;18265:8;;18243:35;;;;;;;;18265:8;18243:10;:35;;-1:-1:-1;18300:4:0;;17819:493;-1:-1:-1;;;;;17819:493:0:o;15112:23::-;;;-1:-1:-1;;;;;15112:23:0;;:::o;18499:110::-;18588:4;18580:21;18499:110;:::o;15808:126::-;15871:4;15548:8;;-1:-1:-1;;;;;15548:8:0;15534:10;:22;;:45;;-1:-1:-1;15574:5:0;;-1:-1:-1;;;;;15574:5:0;15560:10;:19;15534:45;15526:54;;;;;;;;-1:-1:-1;15887:8:0;:17;;-1:-1:-1;;;;;15887:17:0;;-1:-1:-1;;15887:17:0;;;;;;;15808:126;;;:::o;18324:163::-;18380:17;15548:8;;-1:-1:-1;;;;;15548:8:0;15534:10;:22;;:45;;-1:-1:-1;15574:5:0;;-1:-1:-1;;;;;15574:5:0;15560:10;:19;15534:45;15526:54;;;;;;;;18409:48;;:10;;18439:4;18431:21;;18409:48;;;;;;;;18431:21;18409:10;:48;;-1:-1:-1;18475:4:0;;-1:-1:-1;;;;18324:163:0;:::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;217:208;-1:-1:-1;;;217:208:0: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://a43fc4130694e1ebfe07f15bcb9f1b01076e3788c54394e581d20a75c5dbc2f6