Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•  contract ERC20Interface
•  contract ApproveAndCallFallBack
•  contract Owned
•  contract Lock
•    - function tokensLocked(address _of, by ...
•    - function tokensUnlockable(address _of ...
•    - function unlock(address _of)
•  contract JACSToken is ERC20Interfa ...
•    - function totalSupply()
•    - function transferWithLock(address _to ...
•    - function tokensLocked(address _of, by ...
•    - function tokensUnlockable(address _of ...
•    - function unlock(address _of)
•    - function burn(uint256 tokens)
•    - function _burn(address account, uint2 ...
•    - function totalAllocatedTokens(uint256 ...
•    - function balanceOf(address tokenOwner ...
•    - function transfer(address to, uint to ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
•    - function allowance(address tokenOwner ...
•    - function approveAndCall(address spend ...
•    - function ()
•    - function transferAnyERC20Token(addres ...
•  contract JACSTokenSale *
•    - function setFounderMultiSigAddress(ad ...
•    - function setTokenAddress(address _tok ...
•    - function startTokenSale(uint8 _days)
•    - function endTokenSale()
•    - function getState()
•    - function getTotalTokens(uint256 _amou ...
•    - function getCurrentPrice()
•    - function calcToken(uint256 value)
•    - function buyTokens(address beneficiar ...
•    - function fundTransfer(uint256 weiAmou ...
•    - function()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-10-25
*/

pragma solidity ^0.4.26;
 
// -----------------------------------------------------------------------
//
// Name : JACS Token Sale
//  
// -----------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}

contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
  
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}

contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
}

contract Owned {
address public owner;
address public newOwner;
    event OwnershipTransferred(address indexed _from, address indexed _to);
    constructor() public {
owner = msg.sender;
}
    modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
 emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
   }
    
  }

contract Lock {
    
     /**lock
     * @dev Reasons why a user's tokens have been locked
     */
    mapping(address => bytes32[]) public lockReason;
    mapping(address => uint256) public balances;

    /**
     * @dev locked token structure
     */
    struct LockToken {
        uint256 amount;
        uint256 validity;
        bool claimed;
    }

    /**
     * @dev Holds number & validity of tokens locked for a given reason for
     *      a specified address
     */
    mapping(address => mapping(bytes32 => LockToken)) public locked;

    /**
     * @dev Records data of all the tokens Locked
     */
    event Locked(
        address indexed _of,
        bytes32 indexed _reason,
        uint256 _amount,
        uint256 _validity
    );
    /**
     * @dev Records data of all the tokens unlocked
     */
    event Unlocked(
        address indexed _of,
        bytes32 indexed _reason,
        uint256 _amount
    );

    /**
     * @dev Returns tokens locked for a specified address for a
     *      specified reason
     *
     * @param _of The address whose tokens are locked
     * @param _reason The reason to query the lock tokens for
     */
    function tokensLocked(address _of, bytes32 _reason)
    public view returns(uint256 amount);

    /**
     * @dev Returns unlockable tokens for a specified address for a specified reason
     * @param _of The address to query the the unlockable token count of
     * @param _reason The reason to query the unlockable tokens for
     */
    function tokensUnlockable(address _of, bytes32 _reason)
    public view returns(uint256 amount);

    /**
     * @dev Unlocks the unlockable tokens of a specified address
     * @param _of Address of user, claiming back unlockable tokens
     */
    function unlock(address _of)
    public returns(uint256 unlockableTokens);
}

contract JACSToken is ERC20Interface, Owned, Lock {
    using SafeMath for uint;
    string public symbol;
    string public  name;
    uint8 public decimals;
    uint256 public tokensForTokenSale; 
    address public tokenSaleAddress;                    // address of TokenSale contract
    uint256 public totalAllocatedTokens;                // variable to regulate the funds allocation
    uint256 public ownerHold; 
    uint internal _totalSupply;
    mapping(address => uint) public balances;
    mapping(address => mapping(address => uint)) public allowed;
    
        /**
     * @dev Error messages for require statements
     */
    string internal constant AMOUNT_ZERO = "Amount can not be 0";
    string internal constant ONLY_OWNER = "Only owner has the right to perform this action";
    address public owner = msg.sender;
    
    constructor( address _tokensaleContract) public {
           symbol = "JACS";
           name = "JACS Token";
           decimals = 18;
           tokenSaleAddress = _tokensaleContract;
           _totalSupply = 536870912 * 10**uint(decimals);
           
           tokensForTokenSale = 268435456 * 10**uint(decimals);
           ownerHold = 268435456 * 10**uint(decimals);
           
            balances[tokenSaleAddress] = tokensForTokenSale;
            balances[owner] = ownerHold;
            
            emit Transfer(address(0), tokenSaleAddress, tokensForTokenSale);
            emit Transfer(address(0), owner, ownerHold);
         }
         // ------------------------------------------------------------------
        // Total supply
        // -------------------------------------------------------------------
        function totalSupply() public constant returns (uint) {
             return _totalSupply.sub(balances[address(0)]);
        }
     // ------------------------------------------------------------------
    // modifier
    // ------------------------------------------------------------------
      modifier onlyTokenSale() {
        require(msg.sender == tokenSaleAddress);
    _;
  }
  
    modifier onlyOwner {
        require(msg.sender == owner, ONLY_OWNER);
        _;
    }
    
       /**lock
     * @dev Transfers and Locks a specified amount of tokens,
     *      for a specified reason and time
     * @param _to adress to which tokens are to be transfered
     * @param _reason The reason to lock tokens
     * @param _amount Number of tokens to be transfered and locked
     * @param _days Number of days for locked token
     */
    function transferWithLock(address _to, bytes32 _reason, uint256 _amount, uint256 _days)
    public
    onlyOwner 
    returns(bool) {
        uint256 validUntil = now.add(_days.mul(86400)); //solhint-disable-line
        require(_amount != 0, AMOUNT_ZERO);

        if (locked[_to][_reason].amount == 0)
            lockReason[_to].push(_reason);

        transfer(address(this), _amount);

        locked[_to][_reason] = LockToken(_amount, validUntil, false);

        emit Locked(_to, _reason, _amount, validUntil);
        return true;
    }

    /**
     * @dev Returns tokens locked for a specified address for a
     *      specified reason
     * @param _of The address whose tokens are locked
     * @param _reason The reason to query the lock tokens for
     */
    function tokensLocked(address _of, bytes32 _reason)
    public
    view
    returns(uint256 amount) {
        if (!locked[_of][_reason].claimed)
            amount = locked[_of][_reason].amount;
    }

    /**
     * @dev Returns unlockable tokens for a specified address for a specified reason
     * @param _of The address to query the the unlockable token count of
     * @param _reason The reason to query the unlockable tokens for
     */
    function tokensUnlockable(address _of, bytes32 _reason)
    public
    view
    returns(uint256 amount) {
        if (locked[_of][_reason].validity <= now && !locked[_of][_reason].claimed) //solhint-disable-line
            amount = locked[_of][_reason].amount;
    }

    /**
     * @dev Unlocks the unlockable tokens of a specified address
     * @param _of Address of user, claiming back unlockable tokens 
     */
    function unlock(address _of)
    public
    returns(uint256 unlockableTokens) {
        uint256 lockedTokens;

        for (uint256 i = 0; i < lockReason[_of].length; i++) {
            lockedTokens = tokensUnlockable(_of, lockReason[_of][i]);
            if (lockedTokens > 0) {
                unlockableTokens = unlockableTokens.add(lockedTokens);
                locked[_of][lockReason[_of][i]].claimed = true;
                emit Unlocked(_of, lockReason[_of][i], lockedTokens); 
                
                if (unlockableTokens > 0){
                    this.transfer(_of, unlockableTokens);
                }
            }
        }
    }

    /**
     *  @dev Internal function that burns an amount of the token
     * @param tokens The amount that will be burnt.
     */

    function burn(uint256 tokens) public onlyOwner  returns(bool) {
        _burn(owner, tokens);
        return true;
    }
    
   /**
   * @dev Internal function that burns an amount of the token of a given
   * account.
   * @param account The account whose tokens will be burnt.
   * @param amount The amount that will be burnt.
   */
  function _burn(address account, uint256 amount) internal {
    require(account != 0);
    require(amount <= balances[account]);

    _totalSupply = _totalSupply.sub(amount);
    balances[account] = balances[account].sub(amount);
    emit Transfer(account, address(0), amount);
  }
  
 /**
      @dev function used to change the supply of total Allocated tokens in the market , it only called by TokenSale
      @param _amount amount is the token quantity added in token supply
  
   */
  function totalAllocatedTokens(uint256 _amount) public onlyTokenSale {
    totalAllocatedTokens += _amount;
  }
  
     // ------------------------------------------------------------------
    // Get the token balance for account `tokenOwner`
    // -------------------------------------------------------------------
     function balanceOf(address tokenOwner) public constant returns (uint balance) {
         return balances[tokenOwner];
    }
     // ------------------------------------------------------------------
     // Transfer the balance from token owner's account to `to` account
    // - Owner's account must have sufficient balance to transfer
     // - 0 value transfers are allowed
     // ------------------------------------------------------------------
     function transfer(address to, uint tokens) public returns (bool success) {
        balances[msg.sender] = balances[msg.sender].sub(tokens);
        balances[to] = balances[to].add(tokens);
        emit Transfer(msg.sender, to, tokens);
         return true;
     }
     // ------------------------------------------------------------------
    // Token owner can approve for `spender` to transferFrom(...) `tokens`
     // from the token owner's account
  // recommends that there are no checks for the approval double-spend
 // attack
 // as this should be implemented in user interfaces
     // ------------------------------------------------------------------
    function approve(address spender, uint tokens) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
         return true;
     }
  // -------------------------------------------------------------------
  // Transfer `tokens` from the `from` account to the `to` account
  //
  // The calling account must already have sufficient tokens
 // approve(...)-d
 // for spending from the `from` account and
  // - From account must have sufficient balance to transfer
  // - Spender must have sufficient allowance to transfer
   // - 0 value transfers are allowed
  // -------------------------------------------------------------------
    function transferFrom(address from, address to, uint tokens) public returns (bool success) {
        balances[from] = balances[from].sub(tokens);
         allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
         balances[to] = balances[to].add(tokens);
         emit Transfer(from, to, tokens);
         return true;
     }
    // -------------------------------------------------------------------
     // transferred to the spender's account
     // ------------------------------------------------------------------
     function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
         return allowed[tokenOwner][spender];
    }
     // ------------------------------------------------------------------
    // Token owner can approve for `spender` to transferFrom(...) `tokens`
    // from the token owner's account. The `spender` contract function
     // `receiveApproval(...)` is then executed
     // ------------------------------------------------------------------
     function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) {
         allowed[msg.sender][spender] = tokens;
         emit Approval(msg.sender, spender, tokens);
         ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
         return true;
     }
    // -------------------------------------------------------------------
     // Don't accept ETH
    // -------------------------------------------------------------------
     function () external payable {
         revert();
     }
// -------------------------------------------------------------------
     // Owner can transfer out any accidentally sent ERC20 tokens
    // -------------------------------------------------------------------
    function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
        return ERC20Interface(tokenAddress).transfer(owner, tokens);
    }
}

contract JACSTokenSale {

    using SafeMath for uint256;
    
//////////////////////////////////////////// VARIABLES ///////////////////////////////////////////////// 

    JACSToken public token;                         // Token variable
    uint256 public tokeSaleStartTime;               // It should be XXXXXXXXXXX starting time of tokeSale
    uint256 public tokenSaleEndTime;                // It should be xxxxxxxxxxx token Sale End Time
    uint256 public totalWeiRaised;                  // Flag to track the amount raised

    // Price as per week in token sale

    uint256 internal firstWeekPrice =2;
    uint256 internal secondWeekPrice=3;
    uint256 internal thirdWeekPrice =4;                              
    uint256 internal fourthWeekPrice=5; 
    
    bool internal isTokenDeployed = false;               // Flag to track the token deployment
    bool public isTokenSaleActive = false;               // Flag to track the TokenSale active or not
    // Addresses
    address public founderMultiSigAddress;          // Founders multi sign address
    address public remainingTokenHolder;            // Address to hold the remaining tokens after TokenSale end
    
    enum State { TokenSale }

   
    //Events
    event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount); 
    event TokenSaleClosed(uint256 _blockTimeStamp);
    event ChangeFoundersWalletAddress(uint256 _blockTimeStamp, address indexed _foundersWalletAddress);

    //Modifiers
    modifier tokenIsDeployed() {
        require(isTokenDeployed == true);
        _;
    }

    modifier nonZeroAddress(address _to) {
        require(_to != 0x0);
        _;
    }
    
    modifier nonZeroEth() {
        require(msg.value > 0);
        _;
    }
    
    modifier onlyFounders() {
        require(msg.sender == founderMultiSigAddress);
        _;
    }
     
    modifier onlyremainingTokenHolder() {
        require(msg.sender == remainingTokenHolder);
        _;
    }
    
    modifier onlyPublic() {
        require(msg.sender != founderMultiSigAddress);
        _;
    }
//////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////
   
    constructor(address _founderWalletAddress , address _remainingTokenHolder) public {
        founderMultiSigAddress = _founderWalletAddress;
        remainingTokenHolder = _remainingTokenHolder;
      
    }

    /**
        @dev function to change the founder multisig wallet address
        @param _newFounderAddress new address of founder
     */

     function setFounderMultiSigAddress(address _newFounderAddress) public
     onlyFounders 
     {
        founderMultiSigAddress = _newFounderAddress;
        emit ChangeFoundersWalletAddress(now, founderMultiSigAddress);
     }
    

    /**
        @dev attach the token address with the TokenSale conract 
        @param _tokenAddress address of the respective token contract 
    
     */
         
    function setTokenAddress(address _tokenAddress) 
    external 
    onlyFounders 
    nonZeroAddress(_tokenAddress) 
    {
        require(isTokenDeployed == false);
        token = JACSToken(_tokenAddress);
        isTokenDeployed = true;
    }

    /**
        @dev startTokenSale function use to start the TokenSale at the calling function time
        @dev _days No. of days to which TokenSale get active
        @return bool
     */
    
    function startTokenSale(uint8 _days) public
    onlyFounders 
    tokenIsDeployed 
    returns (bool)
    {
            tokeSaleStartTime = now;                            
            tokenSaleEndTime = tokeSaleStartTime + _days * 1 days; 
            isTokenSaleActive = !isTokenSaleActive;
            return true;
    }


    /**
        @dev function call after tokenSaleEndTime 
        it transfers the remaining tokens to remainingTokenHolder address
        @return bool
    */

    function endTokenSale() public onlyremainingTokenHolder returns (bool) {
        require(now > tokenSaleEndTime);
        uint256 remainingToken = token.balanceOf(this);  // remaining tokens

        if (remainingToken != 0) {
          token.transfer(remainingTokenHolder, remainingToken); 
          isTokenSaleActive = false;
          tokenSaleEndTime = now; 
          emit TokenSaleClosed(now);
          return true; 
        } 
        return false;
    }

    // function to get the current state of the token sale
    function getState() internal constant returns(State) {
        if(isTokenSaleActive) {
            return State.TokenSale;
        }
    }

   // get the amount of tokens a user would receive for a specific amount of ether
   function getTotalTokens(uint256 _amountOfEth) public view returns(uint256) {
       if (getState() == State.TokenSale) {
           return calcToken(_amountOfEth);
       }else {
           revert();
       }
      
   } 
   
    // function provide the current price 
    function getCurrentPrice() internal view returns (uint256) {
        
        if (now > tokeSaleStartTime + 21 days) {
            return fourthWeekPrice;
        }
        if (now > tokeSaleStartTime + 14 days) {
            return thirdWeekPrice;
        }
        if (now > tokeSaleStartTime + 7 days) {
            return secondWeekPrice;
        }
        if (now > tokeSaleStartTime) {
            return firstWeekPrice;
        }
    }

    // calculate the amount of tokens
    function calcToken(uint256 value)
        internal
        view
        returns(uint256 amount){
             amount =  value.mul(10000).div(getCurrentPrice());
             return amount;
        }
        
    // Buy token function call only in duration of TokenSale active 
    function buyTokens(address beneficiary) public nonZeroEth tokenIsDeployed onlyPublic nonZeroAddress(beneficiary) payable returns(bool) {
        if(getState() == State.TokenSale) {
            require(now < tokenSaleEndTime);
            fundTransfer(msg.value);
            totalWeiRaised = totalWeiRaised.add(msg.value);
             uint256 amount = calcToken(msg.value);
        
         if (token.transfer(beneficiary, amount)) {
                token.totalAllocatedTokens(amount); 
                emit TokenPurchase(beneficiary, msg.value, amount);
            }
            return true;         
        }
        else {
            revert();
        }
        
    }
    
    // function to transfer the funds to founders account
    function fundTransfer(uint256 weiAmount) internal {
        founderMultiSigAddress.transfer(weiAmount);
    }
    
    // send ether to the contract address
    function() public payable {
        buyTokens(msg.sender);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"tokeSaleStartTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_newFounderAddress","type":"address"}],"name":"setFounderMultiSigAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_tokenAddress","type":"address"}],"name":"setTokenAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"founderMultiSigAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"endTokenSale","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"remainingTokenHolder","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalWeiRaised","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_days","type":"uint8"}],"name":"startTokenSale","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"isTokenSaleActive","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenSaleEndTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"}],"name":"buyTokens","outputs":[{"name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_amountOfEth","type":"uint256"}],"name":"getTotalTokens","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"_founderWalletAddress","type":"address"},{"name":"_remainingTokenHolder","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"beneficiary","type":"address"},{"indexed":false,"name":"value","type":"uint256"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"TokenPurchase","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_blockTimeStamp","type":"uint256"}],"name":"TokenSaleClosed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_blockTimeStamp","type":"uint256"},{"indexed":true,"name":"_foundersWalletAddress","type":"address"}],"name":"ChangeFoundersWalletAddress","type":"event"}]

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

0000000000000000000000006b306026eebc53e9fa9ec84221fe344c39f17b7a0000000000000000000000009852884370b5d817287285112b0a569695a9f16a

-----Decoded View---------------
Arg [0] : _founderWalletAddress (address): 0x6B306026Eebc53E9fA9ec84221fE344c39F17b7a
Arg [1] : _remainingTokenHolder (address): 0x9852884370b5d817287285112B0a569695A9f16a

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000006b306026eebc53e9fa9ec84221fe344c39f17b7a
Arg [1] : 0000000000000000000000009852884370b5d817287285112b0a569695a9f16a

14083:6864:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20915:21;20925:10;20915:9;:21::i;:::-;;14083:6864;14334:32;;8:9:-1;5:2;;;30:1;27;20:12;5:2;14334:32:0;;;;;;;;;;;;;;;;;;;;;;;16705:231;;8:9:-1;5:2;;;30:1;27;20:12;5:2;16705:231:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;17124:252;;8:9:-1;5:2;;;30:1;27;20:12;5:2;17124:252:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;15092:37;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15092:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;18096:475;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18096:475:0;;;;;;;;;;;;;;;;;;;;;;;;;;;15176:35;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15176:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;14542:29;;8:9:-1;5:2;;;30:1;27;20:12;5:2;14542:29:0;;;;;;;;;;;;;;;;;;;;;;;17586:332;;8:9:-1;5:2;;;30:1;27;20:12;5:2;17586:332:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14971:37;;8:9:-1;5:2;;;30:1;27;20:12;5:2;14971:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;14441:31;;8:9:-1;5:2;;;30:1;27;20:12;5:2;14441:31:0;;;;;;;;;;;;;;;;;;;;;;;19948:693;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14263:22;;8:9:-1;5:2;;;30:1;27;20:12;5:2;14263:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;18872:227;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18872:227:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19948:693;20077:4;20289:14;15860:1;15848:9;:13;15840:22;;;;;;;;15675:4;15656:23;;:15;;;;;;;;;;;:23;;;15648:32;;;;;;;;16184:22;;;;;;;;;;;16170:36;;:10;:36;;;;16162:45;;;;;;;;20048:11;15771:3;15764;:10;;;;15756:19;;;;;;;;20111:15;20097:29;;;;;;;;:10;:8;:10::i;:::-;:29;;;;;;;;;20094:530;;;20157:16;;20151:3;:22;20143:31;;;;;;;;20189:23;20202:9;20189:12;:23::i;:::-;20244:29;20263:9;20244:14;;:18;;:29;;;;:::i;:::-;20227:14;:46;;;;20306:20;20316:9;20306;:20::i;:::-;20289:37;;20352:5;;;;;;;;;;;:14;;;20367:11;20380:6;20352:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20352:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;20352:35:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;20352:35:0;;;;;;;;;;;;;;;;20348:180;;;20408:5;;;;;;;;;;;:26;;;20435:6;20408:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20408:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;20408:34:0;;;;20481:11;20467:45;;;20494:9;20505:6;20467:45;;;;;;;;;;;;;;;;;;;;;;;;20348:180;20549:4;20542:11;;;;20094:530;20604:8;;;15786:1;16218;19948:693;;;;:::o;14334:32::-;;;;:::o;16705:231::-;15951:22;;;;;;;;;;;15937:36;;:10;:36;;;15929:45;;;;;;;;16837:18;16812:22;;:43;;;;;;;;;;;;;;;;;;16904:22;;;;;;;;;;;16871:56;;;16899:3;16871:56;;;;;;;;;;;;;;;;;;16705:231;:::o;17124:252::-;15951:22;;;;;;;;;;;15937:36;;:10;:36;;;15929:45;;;;;;;;17227:13;15771:3;15764;:10;;;;15756:19;;;;;;;;17286:5;17267:24;;:15;;;;;;;;;;;:24;;;17259:33;;;;;;;;17321:13;17303:5;;:32;;;;;;;;;;;;;;;;;;17364:4;17346:15;;:22;;;;;;;;;;;;;;;;;;15985:1;17124:252;:::o;15092:37::-;;;;;;;;;;;;;:::o;18096:475::-;18161:4;18220:22;16076:20;;;;;;;;;;;16062:34;;:10;:34;;;16054:43;;;;;;;;18192:16;;18186:3;:22;18178:31;;;;;;;;18245:5;;;;;;;;;;;:15;;;18261:4;18245:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18245:21:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;18245:21:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;18245:21:0;;;;;;;;;;;;;;;;18220:46;;18322:1;18304:14;:19;;18300:240;;;18338:5;;;;;;;;;;;:14;;;18353:20;;;;;;;;;;;18375:14;18338:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18338:52:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;18338:52:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;18338:52:0;;;;;;;;;;;;;;;;;18424:5;18404:17;;:25;;;;;;;;;;;;;;;;;;18461:3;18442:16;:22;;;;18483:20;18499:3;18483:20;;;;;;;;;;;;;;;;;;18523:4;18516:11;;;;18300:240;18558:5;18551:12;;16108:1;18096:475;;:::o;15176:35::-;;;;;;;;;;;;;:::o;14542:29::-;;;;:::o;17586:332::-;17685:4;15951:22;;;;;;;;;;;15937:36;;:10;:36;;;15929:45;;;;;;;;15675:4;15656:23;;:15;;;;;;;;;;;:23;;;15648:32;;;;;;;;17731:3;17711:17;:23;;;;17824:6;17816:5;:14;;;17796:34;;:17;;:34;17777:16;:53;;;;17867:17;;;;;;;;;;;17866:18;17846:17;;:38;;;;;;;;;;;;;;;;;;17906:4;17899:11;;17586:332;;;:::o;14971:37::-;;;;;;;;;;;;;:::o;14441:31::-;;;;:::o;14263:22::-;;;;;;;;;;;;;:::o;18872:227::-;18938:7;18975:15;18961:29;;;;;;;;:10;:8;:10::i;:::-;:29;;;;;;;;;18957:128;;;19013:23;19023:12;19013:9;:23::i;:::-;19006:30;;;;18957:128;19066:8;;;18872:227;;;;:::o;18639:142::-;18685:5;18706:17;;;;;;;;;;;18703:71;;;18747:15;18740:22;;;;18703:71;18639:142;;:::o;20712:111::-;20773:22;;;;;;;;;;;:31;;:42;20805:9;20773:42;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;20773:42:0;20712:111;:::o;238:94::-;290:6;309:1;305;:5;301:9;;326:1;321;:6;;313:15;;;;;;;;238:94;;;;:::o;19658:204::-;19741:14;19782:39;19803:17;:15;:17::i;:::-;19782:16;19792:5;19782;:9;;:16;;;;:::i;:::-;:20;;:39;;;;:::i;:::-;19772:49;;19844:6;19837:13;;19658:204;;;:::o;19155:456::-;19205:7;19265;19245:17;;:27;19239:3;:33;19235:88;;;19296:15;;19289:22;;;;19235:88;19363:7;19343:17;;:27;19337:3;:33;19333:87;;;19394:14;;19387:21;;;;19333:87;19460:6;19440:17;;:26;19434:3;:32;19430:87;;;19490:15;;19483:22;;;;19430:87;19537:17;;19531:3;:23;19527:77;;;19578:14;;19571:21;;;;19527:77;19155:456;;:::o;430:108::-;482:6;501:1;497;:5;493:9;;518:1;513;:6;:20;;;;532:1;527;523;:5;;;;;;;;:10;513:20;505:29;;;;;;;;430:108;;;;:::o;540:93::-;592:6;615:1;611;:5;603:14;;;;;;;;628:1;624;:5;;;;;;;;620:9;;540:93;;;;:::o

bzzr://29999ac774d7f74ddc8bfde614bef9041bd9832aa9884ce82be15d57beeba3b6