Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract IERC20Token
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address _owner)
•    - function allowance(address _owner, ad ...
•    - function transfer(address _to, uint25 ...
•    - function transferFrom(address _from, ...
•    - function approve(address _spender, ui ...
•  contract Utils
• library SafeMath
•    - function add(uint256 _x, uint256 _y)
•    - function sub(uint256 _x, uint256 _y)
•    - function mul(uint256 _x, uint256 _y)
•    - function div(uint256 _x, uint256 _y)
•  contract ERC20Token is IERC20Token ...
•    - function transfer(address _to, uint25 ...
•    - function transferFrom(address _from, ...
•    - function approve(address _spender, ui ...
•  contract IOwned
•    - function owner()
•    - function transferOwnership(address _n ...
•    - function acceptOwnership()
•  contract ISmartToken is IOwned, IE ...
•    - function disableTransfers(bool _disab ...
•    - function issue(address _to, uint256 _ ...
•    - function destroy(address _from, uint2 ...
•  contract Owned is IOwned
•    - function transferOwnership(address _n ...
•    - function acceptOwnership()
•  contract ITokenHolder is IOwned
•    - function withdrawTokens(IERC20Token _ ...
•  contract INonStandardERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address _owner)
•    - function allowance(address _owner, ad ...
•    - function transfer(address _to, uint25 ...
•    - function transferFrom(address _from, ...
•    - function approve(address _spender, ui ...
•  contract TokenHolder is ITokenHold ...
•    - function withdrawTokens(IERC20Token _ ...
•  contract SmartToken is ISmartToken ... *
•    - function disableTransfers(bool _disab ...
•    - function issue(address _to, uint256 _ ...
•    - function destroy(address _from, uint2 ...
•    - function transfer(address _to, uint25 ...
•    - function transferFrom(address _from, ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-03-05
*/

// File: contracts/token/interfaces/IERC20Token.sol

pragma solidity 0.4.26;

/*
    ERC20 Standard Token interface
*/
contract IERC20Token {
    // these functions aren't abstract since the compiler emits automatically generated getter functions as external
    function name() public view returns (string) {this;}
    function symbol() public view returns (string) {this;}
    function decimals() public view returns (uint8) {this;}
    function totalSupply() public view returns (uint256) {this;}
    function balanceOf(address _owner) public view returns (uint256) {_owner; this;}
    function allowance(address _owner, address _spender) public view returns (uint256) {_owner; _spender; this;}

    function transfer(address _to, uint256 _value) public returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
    function approve(address _spender, uint256 _value) public returns (bool success);
}

// File: contracts/utility/Utils.sol

pragma solidity 0.4.26;

/**
  * @dev Utilities & Common Modifiers
*/
contract Utils {
    /**
      * constructor
    */
    constructor() public {
    }

    // verifies that an amount is greater than zero
    modifier greaterThanZero(uint256 _amount) {
        require(_amount > 0);
        _;
    }

    // validates an address - currently only checks that it isn't null
    modifier validAddress(address _address) {
        require(_address != address(0));
        _;
    }

    // verifies that the address is different than this contract address
    modifier notThis(address _address) {
        require(_address != address(this));
        _;
    }

}

// File: contracts/utility/SafeMath.sol

pragma solidity 0.4.26;

/**
  * @dev Library for basic math operations with overflow/underflow protection
*/
library SafeMath {
    /**
      * @dev returns the sum of _x and _y, reverts if the calculation overflows
      * 
      * @param _x   value 1
      * @param _y   value 2
      * 
      * @return sum
    */
    function add(uint256 _x, uint256 _y) internal pure returns (uint256) {
        uint256 z = _x + _y;
        require(z >= _x);
        return z;
    }

    /**
      * @dev returns the difference of _x minus _y, reverts if the calculation underflows
      * 
      * @param _x   minuend
      * @param _y   subtrahend
      * 
      * @return difference
    */
    function sub(uint256 _x, uint256 _y) internal pure returns (uint256) {
        require(_x >= _y);
        return _x - _y;
    }

    /**
      * @dev returns the product of multiplying _x by _y, reverts if the calculation overflows
      * 
      * @param _x   factor 1
      * @param _y   factor 2
      * 
      * @return product
    */
    function mul(uint256 _x, uint256 _y) internal pure returns (uint256) {
        // gas optimization
        if (_x == 0)
            return 0;

        uint256 z = _x * _y;
        require(z / _x == _y);
        return z;
    }

      /**
        * ev Integer division of two numbers truncating the quotient, reverts on division by zero.
        * 
        * aram _x   dividend
        * aram _y   divisor
        * 
        * eturn quotient
    */
    function div(uint256 _x, uint256 _y) internal pure returns (uint256) {
        require(_y > 0);
        uint256 c = _x / _y;

        return c;
    }
}

// File: contracts/token/ERC20Token.sol

pragma solidity 0.4.26;




/**
  * @dev ERC20 Standard Token implementation
*/
contract ERC20Token is IERC20Token, Utils {
    using SafeMath for uint256;


    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;

    /**
      * @dev triggered when tokens are transferred between wallets
      * 
      * @param _from    source address
      * @param _to      target address
      * @param _value   transfer amount
    */
    event Transfer(address indexed _from, address indexed _to, uint256 _value);

    /**
      * @dev triggered when a wallet allows another wallet to transfer tokens from on its behalf
      * 
      * @param _owner   wallet that approves the allowance
      * @param _spender wallet that receives the allowance
      * @param _value   allowance amount
    */
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

    /**
      * @dev initializes a new ERC20Token instance
      * 
      * @param _name        token name
      * @param _symbol      token symbol
      * @param _decimals    decimal points, for display purposes
      * @param _totalSupply total supply of token units
    */
    constructor(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public {
        require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input

        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        totalSupply = _totalSupply;
        balanceOf[msg.sender] = _totalSupply;
    }

    /**
      * @dev send coins
      * throws on any error rather then return a false flag to minimize user errors
      * 
      * @param _to      target address
      * @param _value   transfer amount
      * 
      * @return true if the transfer was successful, false if it wasn't
    */
    function transfer(address _to, uint256 _value)
        public
        validAddress(_to)
        returns (bool success)
    {
        balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
        balanceOf[_to] = balanceOf[_to].add(_value);
        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    /**
      * @dev an account/contract attempts to get the coins
      * throws on any error rather then return a false flag to minimize user errors
      * 
      * @param _from    source address
      * @param _to      target address
      * @param _value   transfer amount
      * 
      * @return true if the transfer was successful, false if it wasn't
    */
    function transferFrom(address _from, address _to, uint256 _value)
        public
        validAddress(_from)
        validAddress(_to)
        returns (bool success)
    {
        allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
        balanceOf[_from] = balanceOf[_from].sub(_value);
        balanceOf[_to] = balanceOf[_to].add(_value);
        emit Transfer(_from, _to, _value);
        return true;
    }

    /**
      * @dev allow another account/contract to spend some tokens on your behalf
      * throws on any error rather then return a false flag to minimize user errors
      * 
      * also, to minimize the risk of the approve/transferFrom attack vector
      * (see https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/), approve has to be called twice
      * in 2 separate transactions - once to change the allowance to 0 and secondly to change it to the new allowance value
      * 
      * @param _spender approved address
      * @param _value   allowance amount
      * 
      * @return true if the approval was successful, false if it wasn't
    */
    function approve(address _spender, uint256 _value)
        public
        validAddress(_spender)
        returns (bool success)
    {
        // if the allowance isn't 0, it can only be updated to 0 to prevent an allowance change immediately after withdrawal
        require(_value == 0 || allowance[msg.sender][_spender] == 0);

        allowance[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }
}

// File: contracts/utility/interfaces/IOwned.sol

pragma solidity 0.4.26;

/*
    Owned contract interface
*/
contract IOwned {
    // this function isn't abstract since the compiler emits automatically generated getter functions as external
    function owner() public view returns (address) {this;}

    function transferOwnership(address _newOwner) public;
    function acceptOwnership() public;
}

// File: contracts/token/interfaces/ISmartToken.sol

pragma solidity 0.4.26;



/*
    Smart Token interface
*/
contract ISmartToken is IOwned, IERC20Token {
    function disableTransfers(bool _disable) public;
    function issue(address _to, uint256 _amount) public;
    function destroy(address _from, uint256 _amount) public;
}

// File: contracts/utility/Owned.sol

pragma solidity 0.4.26;


/**
  * @dev Provides support and utilities for contract ownership
*/
contract Owned is IOwned {
    address public owner;
    address public newOwner;

    /**
      * @dev triggered when the owner is updated
      * 
      * @param _prevOwner previous owner
      * @param _newOwner  new owner
    */
    event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner);

    /**
      * @dev initializes a new Owned instance
    */
    constructor() public {
        owner = msg.sender;
    }

    // allows execution by the owner only
    modifier ownerOnly {
        require(msg.sender == owner);
        _;
    }

    /**
      * @dev allows transferring the contract ownership
      * the new owner still needs to accept the transfer
      * can only be called by the contract owner
      * 
      * @param _newOwner    new contract owner
    */
    function transferOwnership(address _newOwner) public ownerOnly {
        require(_newOwner != owner);
        newOwner = _newOwner;
    }

    /**
      * @dev used by a new owner to accept an ownership transfer
    */
    function acceptOwnership() public {
        require(msg.sender == newOwner);
        emit OwnerUpdate(owner, newOwner);
        owner = newOwner;
        newOwner = address(0);
    }
}

// File: contracts/utility/interfaces/ITokenHolder.sol

pragma solidity 0.4.26;



/*
    Token Holder interface
*/
contract ITokenHolder is IOwned {
    function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}

// File: contracts/token/interfaces/INonStandardERC20.sol

pragma solidity 0.4.26;

/*
    ERC20 Standard Token interface which doesn't return true/false for transfer, transferFrom and approve
*/
contract INonStandardERC20 {
    // these functions aren't abstract since the compiler emits automatically generated getter functions as external
    function name() public view returns (string) {this;}
    function symbol() public view returns (string) {this;}
    function decimals() public view returns (uint8) {this;}
    function totalSupply() public view returns (uint256) {this;}
    function balanceOf(address _owner) public view returns (uint256) {_owner; this;}
    function allowance(address _owner, address _spender) public view returns (uint256) {_owner; _spender; this;}

    function transfer(address _to, uint256 _value) public;
    function transferFrom(address _from, address _to, uint256 _value) public;
    function approve(address _spender, uint256 _value) public;
}

// File: contracts/utility/TokenHolder.sol

pragma solidity 0.4.26;






/**
  * @dev We consider every contract to be a 'token holder' since it's currently not possible
  * for a contract to deny receiving tokens.
  * 
  * The TokenHolder's contract sole purpose is to provide a safety mechanism that allows
  * the owner to send tokens that were sent to the contract by mistake back to their sender.
  * 
  * Note that we use the non standard ERC-20 interface which has no return value for transfer
  * in order to support both non standard as well as standard token contracts.
  * see https://github.com/ethereum/solidity/issues/4116
*/
contract TokenHolder is ITokenHolder, Owned, Utils {
    /**
      * @dev initializes a new TokenHolder instance
    */
    constructor() public {
    }

    /**
      * @dev withdraws tokens held by the contract and sends them to an account
      * can only be called by the owner
      * 
      * @param _token   ERC20 token contract address
      * @param _to      account to receive the new amount
      * @param _amount  amount to withdraw
    */
    function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)
        public
        ownerOnly
        validAddress(_token)
        validAddress(_to)
        notThis(_to)
    {
        INonStandardERC20(_token).transfer(_to, _amount);
    }
}

// File: contracts/token/SmartToken.sol

pragma solidity 0.4.26;





/**
  * @dev Smart Token
  * 
  * 'Owned' is specified here for readability reasons
*/
contract SmartToken is ISmartToken, Owned, ERC20Token, TokenHolder {
    using SafeMath for uint256;


    string public version = '0.3';

    bool public transfersEnabled = true;    // true if transfer/transferFrom are enabled, false if not

    /**
      * @dev triggered when a smart token is deployed
      * the _token address is defined for forward compatibility, in case the event is trigger by a factory
      * 
      * @param _token  new smart token address
    */
    event NewSmartToken(address _token);

    /**
      * @dev triggered when the total supply is increased
      * 
      * @param _amount  amount that gets added to the supply
    */
    event Issuance(uint256 _amount);

    /**
      * @dev triggered when the total supply is decreased
      * 
      * @param _amount  amount that gets removed from the supply
    */
    event Destruction(uint256 _amount);

    /**
      * @dev initializes a new SmartToken instance
      * 
      * @param _name       token name
      * @param _symbol     token short symbol, minimum 1 character
      * @param _decimals   for display purposes only
    */
    constructor(string _name, string _symbol, uint8 _decimals)
        public
        ERC20Token(_name, _symbol, _decimals, 0)
    {
        emit NewSmartToken(address(this));
    }

    // allows execution only when transfers aren't disabled
    modifier transfersAllowed {
        assert(transfersEnabled);
        _;
    }

    /**
      * @dev disables/enables transfers
      * can only be called by the contract owner
      * 
      * @param _disable    true to disable transfers, false to enable them
    */
    function disableTransfers(bool _disable) public ownerOnly {
        transfersEnabled = !_disable;
    }

    /**
      * @dev increases the token supply and sends the new tokens to an account
      * can only be called by the contract owner
      * 
      * @param _to         account to receive the new amount
      * @param _amount     amount to increase the supply by
    */
    function issue(address _to, uint256 _amount)
        public
        ownerOnly
        validAddress(_to)
        notThis(_to)
    {
        totalSupply = totalSupply.add(_amount);
        balanceOf[_to] = balanceOf[_to].add(_amount);

        emit Issuance(_amount);
        emit Transfer(this, _to, _amount);
    }

    /**
      * @dev removes tokens from an account and decreases the token supply
      * can be called by the contract owner to destroy tokens from any account or by any holder to destroy tokens from his/her own account
      * 
      * @param _from       account to remove the amount from
      * @param _amount     amount to decrease the supply by
    */
    function destroy(address _from, uint256 _amount) public {
        require(msg.sender == _from || msg.sender == owner); // validate input

        balanceOf[_from] = balanceOf[_from].sub(_amount);
        totalSupply = totalSupply.sub(_amount);

        emit Transfer(_from, this, _amount);
        emit Destruction(_amount);
    }

    // ERC20 standard method overrides with some extra functionality

    /**
      * @dev send coins
      * throws on any error rather then return a false flag to minimize user errors
      * in addition to the standard checks, the function throws if transfers are disabled
      * 
      * @param _to      target address
      * @param _value   transfer amount
      * 
      * @return true if the transfer was successful, false if it wasn't
    */
    function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
        assert(super.transfer(_to, _value));
        return true;
    }

    /**
      * @dev an account/contract attempts to get the coins
      * throws on any error rather then return a false flag to minimize user errors
      * in addition to the standard checks, the function throws if transfers are disabled
      * 
      * @param _from    source address
      * @param _to      target address
      * @param _value   transfer amount
      * 
      * @return true if the transfer was successful, false if it wasn't
    */
    function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
        assert(super.transferFrom(_from, _to, _value));
        return true;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_disable","type":"bool"}],"name":"disableTransfers","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"version","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_token","type":"address"},{"name":"_to","type":"address"},{"name":"_amount","type":"uint256"}],"name":"withdrawTokens","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"acceptOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_amount","type":"uint256"}],"name":"issue","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_amount","type":"uint256"}],"name":"destroy","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"transfersEnabled","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"newOwner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_name","type":"string"},{"name":"_symbol","type":"string"},{"name":"_decimals","type":"uint8"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_token","type":"address"}],"name":"NewSmartToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_amount","type":"uint256"}],"name":"Issuance","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_amount","type":"uint256"}],"name":"Destruction","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_from","type":"address"},{"indexed":true,"name":"_to","type":"address"},{"indexed":false,"name":"_value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_owner","type":"address"},{"indexed":true,"name":"_spender","type":"address"},{"indexed":false,"name":"_value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_prevOwner","type":"address"},{"indexed":true,"name":"_newOwner","type":"address"}],"name":"OwnerUpdate","type":"event"}]

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

12871:4444:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3684:18;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3684:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;3684:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7409:470;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;7409:470:0;-1:-1:-1;;;;;7409:470:0;;;;;;;;;;;;;;;;;;;;;;;;;14565:105;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;14565:105:0;;;;;;;;;3764:26;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3764:26:0;;;;;;;;;;;;;;;;;;;;17112:200;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;17112:200:0;-1:-1:-1;;;;;17112:200:0;;;;;;;;;;;;3736:21;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3736:21:0;;;;;;;;;;;;;;;;;;;;;;;12982:29;;8:9:-1;5:2;;;30:1;27;20:12;5:2;12982:29:0;;;;12434:260;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;12434:260:0;-1:-1:-1;;;;;12434:260:0;;;;;;;;;;;;3797:45;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;3797:45:0;-1:-1:-1;;;;;3797:45:0;;;;;9850:187;;8:9:-1;5:2;;;30:1;27;20:12;5:2;9850:187:0;;;;14958:325;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;14958:325:0;-1:-1:-1;;;;;14958:325:0;;;;;;;8824:20;;8:9:-1;5:2;;;30:1;27;20:12;5:2;8824:20:0;;;;;;;;-1:-1:-1;;;;;8824:20:0;;;;;;;;;;;;;;3709;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3709:20:0;;;;15657:338;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;15657:338:0;-1:-1:-1;;;;;15657:338:0;;;;;;;16467:170;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;16467:170:0;-1:-1:-1;;;;;16467:170:0;;;;;;;13020:35;;8:9:-1;5:2;;;30:1;27;20:12;5:2;13020:35:0;;;;8851:23;;8:9:-1;5:2;;;30:1;27;20:12;5:2;8851:23:0;;;;3849:66;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;3849:66:0;-1:-1:-1;;;;;3849:66:0;;;;;;;;;;9619:140;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;9619:140:0;-1:-1:-1;;;;;9619:140:0;;;;;3684:18;;;;;;;;;;;;;;-1:-1:-1;;3684:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;7409:470::-;7526:12;7498:8;-1:-1:-1;;;;;1489:22:0;;;;1481:31;;;;;;7690:11;;;:51;;-1:-1:-1;7715:10:0;7705:21;;;;:9;:21;;;;;;;;-1:-1:-1;;;;;7705:31:0;;;;;;;;;;:36;7690:51;7682:60;;;;;;;;7765:10;7755:21;;;;:9;:21;;;;;;;;-1:-1:-1;;;;;7755:31:0;;;;;;;;;;;;:40;;;7811:38;;;;;;;7755:31;;7765:10;7811:38;;;;;;;;;;;-1:-1:-1;7867:4:0;;7409:470;-1:-1:-1;;;7409:470:0:o;14565:105::-;9345:5;;-1:-1:-1;;;;;9345:5:0;9331:10;:19;9323:28;;;;;;14634:16;:28;;-1:-1:-1;;14634:28:0;14653:9;;14634:28;;;;;;14565:105::o;3764:26::-;;;;:::o;17112:200::-;14326:16;;17211:12;;14326:16;;14319:24;;;;;;17243:38;17262:5;17269:3;17274:6;17243:18;:38::i;:::-;17236:46;;;;;;-1:-1:-1;17300:4:0;17112:200;;;;;:::o;3736:21::-;;;;;;:::o;12982:29::-;;;;;;;;;;;;;;;-1:-1:-1;;12982:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12434:260;9345:5;;-1:-1:-1;;;;;9345:5:0;9331:10;:19;9323:28;;;;;;12565:6;-1:-1:-1;;;;;1489:22:0;;;;1481:31;;;;;;12595:3;-1:-1:-1;;;;;1489:22:0;;;;1481:31;;;;;;12617:3;-1:-1:-1;;;;;1668:25:0;;1688:4;1668:25;;1660:34;;;;;;12656:6;-1:-1:-1;;;;;12638:34:0;;12673:3;12678:7;12638:48;;;;;;;;;;;;;-1:-1:-1;;;;;12638:48:0;-1:-1:-1;;;;;12638:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;12638:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;12638:48:0;;;;1523:1;;9362;12434:260;;;:::o;3797:45::-;;;;;;;;;;;;;:::o;9850:187::-;9917:8;;-1:-1:-1;;;;;9917:8:0;9903:10;:22;9895:31;;;;;;9961:8;;;9954:5;;9942:28;;-1:-1:-1;;;;;9961:8:0;;;;9954:5;;;;9942:28;;;9989:8;;;;9981:16;;-1:-1:-1;;9981:16:0;;;-1:-1:-1;;;;;9989:8:0;;9981:16;;;;10008:21;;;9850:187::o;14958:325::-;9345:5;;-1:-1:-1;;;;;9345:5:0;9331:10;:19;9323:28;;;;;;15060:3;-1:-1:-1;;;;;1489:22:0;;;;1481:31;;;;;;15082:3;-1:-1:-1;;;;;1668:25:0;;1688:4;1668:25;;1660:34;;;;;;15117:11;;:24;;15133:7;15117:24;:15;:24;:::i;:::-;15103:11;:38;-1:-1:-1;;;;;15169:14:0;;;;;;:9;:14;;;;;;:27;;15188:7;15169:27;:18;:27;:::i;:::-;-1:-1:-1;;;;;15152:14:0;;;;;;:9;:14;;;;;;;;;:44;;;;15214:17;;;;;;;;;;;;;;;;;;15247:28;;;;;;;;-1:-1:-1;;;;;15247:28:0;;;15256:4;;-1:-1:-1;;;;;;;;;;;15247:28:0;;;;;;;;1523:1;9362;14958:325;;:::o;8824:20::-;;;-1:-1:-1;;;;;8824:20:0;;:::o;3709:::-;;;;;;;;;;;;;;;-1:-1:-1;;3709:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15657:338;15732:10;-1:-1:-1;;;;;15732:19:0;;;;:42;;-1:-1:-1;15769:5:0;;-1:-1:-1;;;;;15769:5:0;15755:10;:19;15732:42;15724:51;;;;;;;;-1:-1:-1;;;;;15825:16:0;;;;;;:9;:16;;;;;;:29;;15846:7;15825:29;:20;:29;:::i;:::-;-1:-1:-1;;;;;15806:16:0;;;;;;:9;:16;;;;;:48;15879:11;;:24;;15895:7;15879:24;:15;:24;:::i;:::-;15865:11;:38;15921:30;;;;;;;;15937:4;;-1:-1:-1;;;;;15921:30:0;;;-1:-1:-1;;;;;;;;;;;15921:30:0;;;;;;;;15967:20;;;;;;;;;;;;;;;;;15657:338;;:::o;16467:170::-;14326:16;;16547:12;;14326:16;;14319:24;;;;;;16579:27;16594:3;16599:6;16579:14;:27::i;:::-;16572:35;;;;;;-1:-1:-1;16625:4:0;16467:170;;;;:::o;13020:35::-;;;;;;:::o;8851:23::-;;;-1:-1:-1;;;;;8851:23:0;;:::o;3849:66::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;9619:140::-;9345:5;;-1:-1:-1;;;;;9345:5:0;9331:10;:19;9323:28;;;;;;9714:5;;-1:-1:-1;;;;;9701:18:0;;;9714:5;;9701:18;;9693:27;;;;;;9731:8;:20;;-1:-1:-1;;9731:20:0;-1:-1:-1;;;;;9731:20:0;;;;;;;;;;9619:140::o;6257:443::-;6413:12;6361:5;-1:-1:-1;;;;;1489:22:0;;;;1481:31;;;;;;6390:3;-1:-1:-1;;;;;1489:22:0;;;;1481:31;;;;;;-1:-1:-1;;;;;6474:16:0;;;;;;:9;:16;;;;;;;;6491:10;6474:28;;;;;;;;:40;;6507:6;6474:40;:32;:40;:::i;:::-;-1:-1:-1;;;;;6443:16:0;;;;;;:9;:16;;;;;;;;6460:10;6443:28;;;;;;;:71;;;;6544:16;;;:9;:16;;;;;:28;;6565:6;6544:28;:20;:28;:::i;:::-;-1:-1:-1;;;;;6525:16:0;;;;;;;:9;:16;;;;;;:47;;;;6600:14;;;;;;;:26;;6619:6;6600:26;:18;:26;:::i;:::-;-1:-1:-1;;;;;6583:14:0;;;;;;;:9;:14;;;;;;;;;:43;;;;6642:28;;;;;;;6583:14;;6642:28;;;;-1:-1:-1;;;;;;;;;;;6642:28:0;;;;;;;;-1:-1:-1;6688:4:0;;6257:443;-1:-1:-1;;;;;6257:443:0:o;2102:153::-;2162:7;2194;;;2220;;;;2212:16;;;;;;2246:1;2102:153;-1:-1:-1;;;2102:153:0:o;2480:130::-;2540:7;2568:8;;;;2560:17;;;;;;-1:-1:-1;2595:7:0;;;2480:130::o;5545:328::-;5653:12;5630:3;-1:-1:-1;;;;;1489:22:0;;;;1481:31;;;;;;5717:10;5707:21;;;;:9;:21;;;;;;:33;;5733:6;5707:33;:25;:33;:::i;:::-;5693:10;5683:21;;;;:9;:21;;;;;;:57;;;;-1:-1:-1;;;;;5768:14:0;;;;;;:26;;5787:6;5768:26;:18;:26;:::i;:::-;-1:-1:-1;;;;;5751:14:0;;;;;;:9;:14;;;;;;;;;:43;;;;5810:33;;;;;;;5751:14;;5819:10;;-1:-1:-1;;;;;;;;;;;5810:33:0;;;;;;;;;-1:-1:-1;5861:4:0;;5545:328;-1:-1:-1;;;5545:328:0:o

bzzr://1bf32d30476429a93f1c6f14ec5ec5159039c118c39ba99b91adb4a5d3ac3c2f