Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface EIP20Interface
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function transfer(address dst, uint25 ...
•    - function transferFrom(address src, ad ...
•    - function approve(address spender, uin ...
•    - function allowance(address owner, add ...
• interface EIP20NonStandardInterface
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function transfer(address dst, uint25 ...
•    - function transferFrom(address src, ad ...
•    - function approve(address spender, uin ...
•    - function allowance(address owner, add ...
•  contract ExponentialNoError
•    - function truncate(Exp memory exp)
•    - function mul_ScalarTruncate(Exp memor ...
•    - function mul_ScalarTruncateAddUInt(Ex ...
•    - function lessThanExp(Exp memory left, ...
•    - function lessThanOrEqualExp(Exp memor ...
•    - function greaterThanExp(Exp memory le ...
•    - function isZeroExp(Exp memory value)
•    - function safe224(uint n, string memor ...
•    - function safe32(uint n, string memory ...
•    - function add_(Exp memory a, Exp memor ...
•    - function add_(Double memory a, Double ...
•    - function add_(uint a, uint b)
•    - function add_(uint a, uint b, string ...
•    - function sub_(Exp memory a, Exp memor ...
•    - function sub_(Double memory a, Double ...
•    - function sub_(uint a, uint b)
•    - function sub_(uint a, uint b, string ...
•    - function mul_(Exp memory a, Exp memor ...
•    - function mul_(Exp memory a, uint b)
•    - function mul_(uint a, Exp memory b)
•    - function mul_(Double memory a, Double ...
•    - function mul_(Double memory a, uint b ...
•    - function mul_(uint a, Double memory b ...
•    - function mul_(uint a, uint b)
•    - function mul_(uint a, uint b, string ...
•    - function div_(Exp memory a, Exp memor ...
•    - function div_(Exp memory a, uint b)
•    - function div_(uint a, Exp memory b)
•    - function div_(Double memory a, Double ...
•    - function div_(Double memory a, uint b ...
•    - function div_(uint a, Double memory b ...
•    - function div_(uint a, uint b)
•    - function div_(uint a, uint b, string ...
•    - function fraction(uint a, uint b)
• interface Distributor
•    - function asset()
•    - function accruedStored(address accoun ...
•    - function accrue()
•    - function claim(address receiver, uint ...
•  contract Redistributor is Distribu ...
•    - function asset()
•    - function accruedStored(address accoun ...
•    - function accruedStoredInternal(addres ...
•    - function accrueInternal()
•    - function accrue()
•    - function distributeInternal(address a ...
•    - function claim(address receiver, uint ...
•    - function claimAll()
•    - function transfer(address to, uint am ...
•    - function getBlockNumber()
•  contract Staking is Redistributor *
•    - function totalDeposits()
•    - function accountState(address account ...
•    - function deposit(uint amount)
•    - function withdraw(uint amount)
•    - function doTransferIn(address from, u ...
•    - function doTransferOut(address to, ui ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-08-26
*/

pragma solidity ^0.5.16;


// Copied from compound/EIP20Interface
/**
 * @title ERC 20 Token Standard Interface
 *  https://eips.ethereum.org/EIPS/eip-20
 */
interface EIP20Interface {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);

    /**
      * @notice Get the total number of tokens in circulation
      * @return The supply of tokens
      */
    function totalSupply() external view returns (uint256);

    /**
     * @notice Gets the balance of the specified address
     * @param owner The address from which the balance will be retrieved
     * @return The balance
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
      * @notice Transfer `amount` tokens from `msg.sender` to `dst`
      * @param dst The address of the destination account
      * @param amount The number of tokens to transfer
      * @return Whether or not the transfer succeeded
      */
    function transfer(address dst, uint256 amount) external returns (bool success);

    /**
      * @notice Transfer `amount` tokens from `src` to `dst`
      * @param src The address of the source account
      * @param dst The address of the destination account
      * @param amount The number of tokens to transfer
      * @return Whether or not the transfer succeeded
      */
    function transferFrom(address src, address dst, uint256 amount) external returns (bool success);

    /**
      * @notice Approve `spender` to transfer up to `amount` from `src`
      * @dev This will overwrite the approval amount for `spender`
      *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
      * @param spender The address of the account which may transfer tokens
      * @param amount The number of tokens that are approved (-1 means infinite)
      * @return Whether or not the approval succeeded
      */
    function approve(address spender, uint256 amount) external returns (bool success);

    /**
      * @notice Get the current allowance from `owner` for `spender`
      * @param owner The address of the account which owns the tokens to be spent
      * @param spender The address of the account which may transfer tokens
      * @return The number of tokens allowed to be spent (-1 means infinite)
      */
    function allowance(address owner, address spender) external view returns (uint256 remaining);

    event Transfer(address indexed from, address indexed to, uint256 amount);
    event Approval(address indexed owner, address indexed spender, uint256 amount);
}

// Copied from compound/EIP20NonStandardInterface
/**
 * @title EIP20NonStandardInterface
 * @dev Version of ERC20 with no return values for `transfer` and `transferFrom`
 *  See https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
 */
interface EIP20NonStandardInterface {

    /**
     * @notice Get the total number of tokens in circulation
     * @return The supply of tokens
     */
    function totalSupply() external view returns (uint256);

    /**
     * @notice Gets the balance of the specified address
     * @param owner The address from which the balance will be retrieved
     * @return The balance
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    ///
    /// !!!!!!!!!!!!!!
    /// !!! NOTICE !!! `transfer` does not return a value, in violation of the ERC-20 specification
    /// !!!!!!!!!!!!!!
    ///

    /**
      * @notice Transfer `amount` tokens from `msg.sender` to `dst`
      * @param dst The address of the destination account
      * @param amount The number of tokens to transfer
      */
    function transfer(address dst, uint256 amount) external;

    ///
    /// !!!!!!!!!!!!!!
    /// !!! NOTICE !!! `transferFrom` does not return a value, in violation of the ERC-20 specification
    /// !!!!!!!!!!!!!!
    ///

    /**
      * @notice Transfer `amount` tokens from `src` to `dst`
      * @param src The address of the source account
      * @param dst The address of the destination account
      * @param amount The number of tokens to transfer
      */
    function transferFrom(address src, address dst, uint256 amount) external;

    /**
      * @notice Approve `spender` to transfer up to `amount` from `src`
      * @dev This will overwrite the approval amount for `spender`
      *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
      * @param spender The address of the account which may transfer tokens
      * @param amount The number of tokens that are approved
      * @return Whether or not the approval succeeded
      */
    function approve(address spender, uint256 amount) external returns (bool success);

    /**
      * @notice Get the current allowance from `owner` for `spender`
      * @param owner The address of the account which owns the tokens to be spent
      * @param spender The address of the account which may transfer tokens
      * @return The number of tokens allowed to be spent
      */
    function allowance(address owner, address spender) external view returns (uint256 remaining);

    event Transfer(address indexed from, address indexed to, uint256 amount);
    event Approval(address indexed owner, address indexed spender, uint256 amount);
}

// Copied from Compound/ExponentialNoError
/**
 * @title Exponential module for storing fixed-precision decimals
 * @author DeFil
 * @notice Exp is a struct which stores decimals with a fixed precision of 18 decimal places.
 *         Thus, if we wanted to store the 5.1, mantissa would store 5.1e18. That is:
 *         `Exp({mantissa: 5100000000000000000})`.
 */
contract ExponentialNoError {
    uint constant expScale = 1e18;
    uint constant doubleScale = 1e36;
    uint constant halfExpScale = expScale/2;
    uint constant mantissaOne = expScale;

    struct Exp {
        uint mantissa;
    }

    struct Double {
        uint mantissa;
    }

    /**
     * @dev Truncates the given exp to a whole number value.
     *      For example, truncate(Exp{mantissa: 15 * expScale}) = 15
     */
    function truncate(Exp memory exp) pure internal returns (uint) {
        // Note: We are not using careful math here as we're performing a division that cannot fail
        return exp.mantissa / expScale;
    }

    /**
     * @dev Multiply an Exp by a scalar, then truncate to return an unsigned integer.
     */
    function mul_ScalarTruncate(Exp memory a, uint scalar) pure internal returns (uint) {
        Exp memory product = mul_(a, scalar);
        return truncate(product);
    }

    /**
     * @dev Multiply an Exp by a scalar, truncate, then add an to an unsigned integer, returning an unsigned integer.
     */
    function mul_ScalarTruncateAddUInt(Exp memory a, uint scalar, uint addend) pure internal returns (uint) {
        Exp memory product = mul_(a, scalar);
        return add_(truncate(product), addend);
    }

    /**
     * @dev Checks if first Exp is less than second Exp.
     */
    function lessThanExp(Exp memory left, Exp memory right) pure internal returns (bool) {
        return left.mantissa < right.mantissa;
    }

    /**
     * @dev Checks if left Exp <= right Exp.
     */
    function lessThanOrEqualExp(Exp memory left, Exp memory right) pure internal returns (bool) {
        return left.mantissa <= right.mantissa;
    }

    /**
     * @dev Checks if left Exp > right Exp.
     */
    function greaterThanExp(Exp memory left, Exp memory right) pure internal returns (bool) {
        return left.mantissa > right.mantissa;
    }

    /**
     * @dev returns true if Exp is exactly zero
     */
    function isZeroExp(Exp memory value) pure internal returns (bool) {
        return value.mantissa == 0;
    }

    function safe224(uint n, string memory errorMessage) pure internal returns (uint224) {
        require(n < 2**224, errorMessage);
        return uint224(n);
    }

    function safe32(uint n, string memory errorMessage) pure internal returns (uint32) {
        require(n < 2**32, errorMessage);
        return uint32(n);
    }

    function add_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
        return Exp({mantissa: add_(a.mantissa, b.mantissa)});
    }

    function add_(Double memory a, Double memory b) pure internal returns (Double memory) {
        return Double({mantissa: add_(a.mantissa, b.mantissa)});
    }

    function add_(uint a, uint b) pure internal returns (uint) {
        return add_(a, b, "addition overflow");
    }

    function add_(uint a, uint b, string memory errorMessage) pure internal returns (uint) {
        uint c = a + b;
        require(c >= a, errorMessage);
        return c;
    }

    function sub_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
        return Exp({mantissa: sub_(a.mantissa, b.mantissa)});
    }

    function sub_(Double memory a, Double memory b) pure internal returns (Double memory) {
        return Double({mantissa: sub_(a.mantissa, b.mantissa)});
    }

    function sub_(uint a, uint b) pure internal returns (uint) {
        return sub_(a, b, "subtraction underflow");
    }

    function sub_(uint a, uint b, string memory errorMessage) pure internal returns (uint) {
        require(b <= a, errorMessage);
        return a - b;
    }

    function mul_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
        return Exp({mantissa: mul_(a.mantissa, b.mantissa) / expScale});
    }

    function mul_(Exp memory a, uint b) pure internal returns (Exp memory) {
        return Exp({mantissa: mul_(a.mantissa, b)});
    }

    function mul_(uint a, Exp memory b) pure internal returns (uint) {
        return mul_(a, b.mantissa) / expScale;
    }

    function mul_(Double memory a, Double memory b) pure internal returns (Double memory) {
        return Double({mantissa: mul_(a.mantissa, b.mantissa) / doubleScale});
    }

    function mul_(Double memory a, uint b) pure internal returns (Double memory) {
        return Double({mantissa: mul_(a.mantissa, b)});
    }

    function mul_(uint a, Double memory b) pure internal returns (uint) {
        return mul_(a, b.mantissa) / doubleScale;
    }

    function mul_(uint a, uint b) pure internal returns (uint) {
        return mul_(a, b, "multiplication overflow");
    }

    function mul_(uint a, uint b, string memory errorMessage) pure internal returns (uint) {
        if (a == 0 || b == 0) {
            return 0;
        }
        uint c = a * b;
        require(c / a == b, errorMessage);
        return c;
    }

    function div_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
        return Exp({mantissa: div_(mul_(a.mantissa, expScale), b.mantissa)});
    }

    function div_(Exp memory a, uint b) pure internal returns (Exp memory) {
        return Exp({mantissa: div_(a.mantissa, b)});
    }

    function div_(uint a, Exp memory b) pure internal returns (uint) {
        return div_(mul_(a, expScale), b.mantissa);
    }

    function div_(Double memory a, Double memory b) pure internal returns (Double memory) {
        return Double({mantissa: div_(mul_(a.mantissa, doubleScale), b.mantissa)});
    }

    function div_(Double memory a, uint b) pure internal returns (Double memory) {
        return Double({mantissa: div_(a.mantissa, b)});
    }

    function div_(uint a, Double memory b) pure internal returns (uint) {
        return div_(mul_(a, doubleScale), b.mantissa);
    }

    function div_(uint a, uint b) pure internal returns (uint) {
        return div_(a, b, "divide by zero");
    }

    function div_(uint a, uint b, string memory errorMessage) pure internal returns (uint) {
        require(b > 0, errorMessage);
        return a / b;
    }

    function fraction(uint a, uint b) pure internal returns (Double memory) {
        return Double({mantissa: div_(mul_(a, doubleScale), b)});
    }
}

interface Distributor {
    // The asset to be distributed
    function asset() external view returns (address);

    // Return the accrued amount of account based on stored data
    function accruedStored(address account) external view returns (uint);

    // Accrue and distribute for caller, but not actually transfer assets to the caller
    // returns the new accrued amount
    function accrue() external returns (uint);

    // Claim asset, transfer the given amount assets to receiver
    function claim(address receiver, uint amount) external returns (uint);
}

contract Redistributor is Distributor, ExponentialNoError {
    /**
     * @notice The superior Distributor contract
     */
    Distributor public superior;

    // The accrued amount of this address in superior Distributor
    uint public superiorAccruedAmount;

    // The initial accrual index
    uint internal constant initialAccruedIndex = 1e36;

    // The last accrued block number
    uint public accrualBlockNumber;

    // The last accrued index
    uint public globalAccruedIndex;

    // Total count of shares.
    uint internal totalShares;

    struct AccountState {
        /// @notice The share of account
        uint share;
        // The last accrued index of account
        uint accruedIndex;
        /// @notice The accrued but not yet transferred to account
        uint accruedAmount;
    }

    // The AccountState for each account
    mapping(address => AccountState) internal accountStates;

    /*** Events ***/
    // Emitted when dfl is accrued
    event Accrued(uint amount, uint globalAccruedIndex);

    // Emitted when distribute to a account
    event Distributed(address account, uint amount, uint accruedIndex);

    // Emitted when account claims asset
    event Claimed(address account, address receiver, uint amount);

    // Emitted when account transfer asset
    event Transferred(address from, address to, uint amount);

    constructor(Distributor superior_) public {
        // set superior
        superior = superior_;
        // init accrued index
        globalAccruedIndex = initialAccruedIndex;
    }

    function asset() external view returns (address) {
        return superior.asset();
    }

    // Return the accrued amount of account based on stored data
    function accruedStored(address account) external view returns(uint) {
        uint storedGlobalAccruedIndex;
        if (totalShares == 0) {
            storedGlobalAccruedIndex = globalAccruedIndex;
        } else {
            uint superiorAccruedStored = superior.accruedStored(address(this));
            uint delta = sub_(superiorAccruedStored, superiorAccruedAmount);

            Double memory ratio = fraction(delta, totalShares);
            Double memory doubleGlobalAccruedIndex = add_(Double({mantissa: globalAccruedIndex}), ratio);
            storedGlobalAccruedIndex = doubleGlobalAccruedIndex.mantissa;
        }

        (, uint instantAccountAccruedAmount) = accruedStoredInternal(account, storedGlobalAccruedIndex);
        return instantAccountAccruedAmount;
    }

    // Return the accrued amount of account based on stored data
    function accruedStoredInternal(address account, uint withGlobalAccruedIndex) internal view returns(uint, uint) {
        AccountState memory state = accountStates[account];

        Double memory doubleGlobalAccruedIndex = Double({mantissa: withGlobalAccruedIndex});
        Double memory doubleAccountAccruedIndex = Double({mantissa: state.accruedIndex});
        if (doubleAccountAccruedIndex.mantissa == 0 && doubleGlobalAccruedIndex.mantissa > 0) {
            doubleAccountAccruedIndex.mantissa = initialAccruedIndex;
        }

        Double memory deltaIndex = sub_(doubleGlobalAccruedIndex, doubleAccountAccruedIndex);
        uint delta = mul_(state.share, deltaIndex);

        return (delta, add_(state.accruedAmount, delta));
    }

    function accrueInternal() internal {
        uint blockNumber = getBlockNumber();
        if (accrualBlockNumber == blockNumber) {
            return;
        }

        uint newSuperiorAccruedAmount = superior.accrue();
        if (totalShares == 0) {
            accrualBlockNumber = blockNumber;
            return;
        }

        uint delta = sub_(newSuperiorAccruedAmount, superiorAccruedAmount);

        Double memory ratio = fraction(delta, totalShares);
        Double memory doubleAccruedIndex = add_(Double({mantissa: globalAccruedIndex}), ratio);

        // update globalAccruedIndex
        globalAccruedIndex = doubleAccruedIndex.mantissa;
        superiorAccruedAmount = newSuperiorAccruedAmount;
        accrualBlockNumber = blockNumber;

        emit Accrued(delta, doubleAccruedIndex.mantissa);
    }

    /**
     * @notice accrue and returns accrued stored of msg.sender
     */
    function accrue() external returns (uint) {
        accrueInternal();

        (, uint instantAccountAccruedAmount) = accruedStoredInternal(msg.sender, globalAccruedIndex);
        return instantAccountAccruedAmount;
    }

    function distributeInternal(address account) internal {
        (uint delta, uint instantAccruedAmount) = accruedStoredInternal(account, globalAccruedIndex);

        AccountState storage state = accountStates[account];
        state.accruedIndex = globalAccruedIndex;
        state.accruedAmount = instantAccruedAmount;

        // emit Distributed event
        emit Distributed(account, delta, globalAccruedIndex);
    }

    function claim(address receiver, uint amount) external returns (uint) {
        address account = msg.sender;

        // keep fresh
        accrueInternal();
        distributeInternal(account);

        AccountState storage state = accountStates[account];
        require(amount <= state.accruedAmount, "claim: insufficient value");

        // claim from superior
        require(superior.claim(receiver, amount) == amount, "claim: amount mismatch");

        // update storage
        state.accruedAmount = sub_(state.accruedAmount, amount);
        superiorAccruedAmount = sub_(superiorAccruedAmount, amount);

        emit Claimed(account, receiver, amount);

        return amount;
    }

    function claimAll() external {
        address account = msg.sender;

        // accrue and distribute
        accrueInternal();
        distributeInternal(account);

        AccountState storage state = accountStates[account];
        uint amount = state.accruedAmount;

        // claim from superior
        require(superior.claim(account, amount) == amount, "claim: amount mismatch");

        // update storage
        state.accruedAmount = 0;
        superiorAccruedAmount = sub_(superiorAccruedAmount, amount);

        emit Claimed(account, account, amount);
    }

    function transfer(address to, uint amount) external {
        address from = msg.sender;

        // keep fresh
        accrueInternal();
        distributeInternal(from);

        AccountState storage fromState = accountStates[from];
        uint actualAmount = amount;
        if (actualAmount == 0) {
            actualAmount = fromState.accruedAmount;
        }
        require(fromState.accruedAmount >= actualAmount, "transfer: insufficient value");

        AccountState storage toState = accountStates[to];

        // update storage
        fromState.accruedAmount = sub_(fromState.accruedAmount, actualAmount);
        toState.accruedAmount = add_(toState.accruedAmount, actualAmount);

        emit Transferred(from, to, actualAmount);
    }

    function getBlockNumber() public view returns (uint) {
        return block.number;
    }
}

contract Staking is Redistributor {
    // The token to deposit
    address public property;

    /*** Events ***/
    // Event emitted when new property tokens is deposited
    event Deposit(address account, uint amount);

    // Event emitted when new property tokens is withdrawed
    event Withdraw(address account, uint amount);

    constructor(address property_, Distributor superior_) Redistributor(superior_) public {
        property = property_;
    }

    function totalDeposits() external view returns (uint) {
        return totalShares;
    }

    function accountState(address account) external view returns (uint, uint, uint) {
        AccountState memory state = accountStates[account];
        return (state.share, state.accruedIndex, state.accruedAmount);
    }

    // Deposit property tokens
    function deposit(uint amount) external returns (uint) {
        address account = msg.sender;

        // accrue & distribute
        accrueInternal();
        distributeInternal(account);

        // transfer property token in
        uint actualAmount = doTransferIn(account, amount);

        // update storage
        AccountState storage state = accountStates[account];
        totalShares = add_(totalShares, actualAmount);
        state.share = add_(state.share, actualAmount);

        emit Deposit(account, actualAmount);

        return actualAmount;
    }

    // Withdraw property tokens
    function withdraw(uint amount) external returns (uint) {
        address account = msg.sender;
        AccountState storage state = accountStates[account];
        require(state.share >= amount, "withdraw: insufficient value");

        // accrue & distribute
        accrueInternal();
        distributeInternal(account);

        // decrease total deposits
        totalShares = sub_(totalShares, amount);
        state.share = sub_(state.share, amount);

        // transfer property tokens back to account
        doTransferOut(account, amount);

        emit Withdraw(account, amount);

        return amount;
    }

    /*** Safe Token ***/

    /**
     * @dev Similar to EIP20 transfer, except it handles a False result from `transferFrom` and reverts in that case.
     *      This will revert due to insufficient balance or insufficient allowance.
     *      This function returns the actual amount received,
     *      which may be less than `amount` if there is a fee attached to the transfer.
     *
     *      Note: This wrapper safely handles non-standard ERC-20 tokens that do not return a value.
     *            See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
     */
    function doTransferIn(address from, uint amount) internal returns (uint) {
        EIP20NonStandardInterface token = EIP20NonStandardInterface(property);
        uint balanceBefore = EIP20Interface(property).balanceOf(address(this));
        token.transferFrom(from, address(this), amount);

        bool success;
        assembly {
            switch returndatasize()
                case 0 {                       // This is a non-standard ERC-20
                    success := not(0)          // set success to true
                }
                case 32 {                      // This is a compliant ERC-20
                    returndatacopy(0, 0, 32)
                    success := mload(0)        // Set `success = returndata` of external call
                }
                default {                      // This is an excessively non-compliant ERC-20, revert.
                    revert(0, 0)
                }
        }
        require(success, "TOKEN_TRANSFER_IN_FAILED");

        // Calculate the amount that was *actually* transferred
        uint balanceAfter = EIP20Interface(property).balanceOf(address(this));
        require(balanceAfter >= balanceBefore, "TOKEN_TRANSFER_IN_OVERFLOW");
        return balanceAfter - balanceBefore;   // underflow already checked above, just subtract
    }

    /**
     * @dev Similar to EIP20 transfer, except it handles a False success from `transfer` and returns an explanatory
     *      error code rather than reverting. If caller has not called checked protocol's balance, this may revert due to
     *      insufficient cash held in this contract. If caller has checked protocol's balance prior to this call, and verified
     *      it is >= amount, this should not revert in normal conditions.
     *
     *      Note: This wrapper safely handles non-standard ERC-20 tokens that do not return a value.
     *            See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
     */
    function doTransferOut(address to, uint amount) internal {
        EIP20NonStandardInterface token = EIP20NonStandardInterface(property);
        token.transfer(to, amount);

        bool success;
        assembly {
            switch returndatasize()
                case 0 {                      // This is a non-standard ERC-20
                    success := not(0)          // set success to true
                }
                case 32 {                     // This is a complaint ERC-20
                    returndatacopy(0, 0, 32)
                    success := mload(0)        // Set `success = returndata` of external call
                }
                default {                     // This is an excessively non-compliant ERC-20, revert.
                    revert(0, 0)
                }
        }
        require(success, "TOKEN_TRANSFER_OUT_FAILED");
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"property_","type":"address"},{"internalType":"contract Distributor","name":"superior_","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"globalAccruedIndex","type":"uint256"}],"name":"Accrued","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accruedIndex","type":"uint256"}],"name":"Distributed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"accountState","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"accrualBlockNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"accrue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"accruedStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"asset","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"claimAll","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getBlockNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"globalAccruedIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"property","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"superior","outputs":[{"internalType":"contract Distributor","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"superiorAccruedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalDeposits","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

20149:5691:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20149:5691:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20731:221;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;20731:221:0;-1:-1:-1;;;;;20731:221:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;20219:23;;;:::i;:::-;;;;-1:-1:-1;;;;;20219:23:0;;;;;;;;;;;;;;13401:30;;;:::i;:::-;;;;;;;;;;;;;;;;21617:639;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;21617:639:0;;:::i;14536:91::-;;;:::i;20051:::-;;;:::i;14701:799::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14701:799:0;-1:-1:-1;;;;;14701:799:0;;:::i;13331:30::-;;;:::i;20632:91::-;;;:::i;13056:27::-;;;:::i;19270:773::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;19270:773:0;;;;;;;;:::i;:::-;;17950:714;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;17950:714:0;;;;;;;;:::i;13159:33::-;;;:::i;20992:584::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;20992:584:0;;:::i;18672:590::-;;;:::i;17275:227::-;;;:::i;20731:221::-;20793:4;20799;20805;20822:25;;:::i;:::-;-1:-1:-1;;;;;;;;;20850:22:0;;;;;:13;:22;;;;;;;;;20822:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20731:221::o;20219:23::-;;;-1:-1:-1;;;;;20219:23:0;;:::o;13401:30::-;;;;:::o;21617:639::-;21701:10;21666:4;21751:22;;;:13;:22;;;;;21792:11;;21666:4;;21701:10;21792:21;-1:-1:-1;21792:21:0;21784:62;;;;;-1:-1:-1;;;21784:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;21891:16;:14;:16::i;:::-;21918:27;21937:7;21918:18;:27::i;:::-;22008:25;22013:11;;22026:6;22008:4;:25::i;:::-;21994:11;:39;22063:11;;22058:25;;22076:6;22058:4;:25::i;:::-;22044:39;;22149:30;22163:7;22172:6;22149:13;:30::i;:::-;22197:25;;;-1:-1:-1;;;;;22197:25:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22242:6:0;;21617:639;-1:-1:-1;;21617:639:0:o;14536:91::-;14576:7;14603:8;;;;;;;;;-1:-1:-1;;;;;14603:8:0;-1:-1:-1;;;;;14603:14:0;;:16;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;14603:16:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14603:16:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14603:16:0;;-1:-1:-1;14536:91:0;:::o;20051:::-;20122:12;20051:91;:::o;14701:799::-;14763:4;14780:29;14824:11;;14839:1;14824:16;14820:520;;;-1:-1:-1;14884:18:0;;14820:520;;;14935:26;14964:8;;:37;;;-1:-1:-1;;;14964:37:0;;14995:4;14964:37;;;;;;-1:-1:-1;;;;;14964:8:0;;;;:22;;:37;;;;;;;;;;;;;;;:8;:37;;;5:2:-1;;;;30:1;27;20:12;5:2;14964:37:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14964:37:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14964:37:0;15057:21;;14964:37;;-1:-1:-1;15016:10:0;;15029:50;;14964:37;;15029:4;:50::i;:::-;15016:63;;15096:19;;:::i;:::-;15118:28;15127:5;15134:11;;15118:8;:28::i;:::-;15096:50;;15161:38;;:::i;:::-;15202:51;15207:38;;;;;;;;15225:18;;15207:38;;;15247:5;15202:4;:51::i;:::-;15295:33;;-1:-1:-1;;;;;14820:520:0;15355:32;15391:56;15413:7;15422:24;15391:21;:56::i;:::-;15352:95;14701:799;-1:-1:-1;;;;;14701:799:0:o;13331:30::-;;;;:::o;20632:91::-;20704:11;;20632:91;:::o;13056:27::-;;;-1:-1:-1;;;;;13056:27:0;;:::o;19270:773::-;19348:10;19394:16;:14;:16::i;:::-;19421:24;19440:4;19421:18;:24::i;:::-;-1:-1:-1;;;;;19491:19:0;;19458:30;19491:19;;;:13;:19;;;;;19541:6;19562:17;19558:88;;-1:-1:-1;19611:23:0;;;;19558:88;19691:12;19664:9;:23;;;:39;;19656:80;;;;;-1:-1:-1;;;19656:80:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19780:17:0;;19749:28;19780:17;;;:13;:17;;;;;19868:23;;;;19863:43;;19893:12;19863:4;:43::i;:::-;19837:9;:23;;:69;;;;19941:41;19946:7;:21;;;19969:12;19941:4;:41::i;:::-;19917:21;;;:65;20000:35;;;-1:-1:-1;;;;;20000:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;19270:773;;;;;;:::o;17950:714::-;18014:4;18049:10;18095:16;:14;:16::i;:::-;18122:27;18141:7;18122:18;:27::i;:::-;-1:-1:-1;;;;;18191:22:0;;18162:26;18191:22;;;:13;:22;;;;;18242:19;;;;18232:29;;;18224:67;;;;;-1:-1:-1;;;18224:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;18344:8;;;:32;;;-1:-1:-1;;;18344:32:0;;-1:-1:-1;;;;;18344:32:0;;;;;;;;;;;;;;;18380:6;;18344:8;;;;;:14;;:32;;;;;;;;;;;;;;;;;;:8;:32;;;5:2:-1;;;;30:1;27;20:12;5:2;18344:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;18344:32:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;18344:32:0;:42;18336:77;;;;;-1:-1:-1;;;18336:77:0;;;;;;;;;;;;-1:-1:-1;;;18336:77:0;;;;;;;;;;;;;;;18475:33;18480:5;:19;;;18501:6;18475:4;:33::i;:::-;18453:19;;;:55;18548:21;;18543:35;;18571:6;18543:4;:35::i;:::-;18519:21;:59;18596:34;;;-1:-1:-1;;;;;18596:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18650:6:0;;17950:714;-1:-1:-1;;;17950:714:0:o;13159:33::-;;;;:::o;20992:584::-;21040:4;21075:10;21130:16;:14;:16::i;:::-;21157:27;21176:7;21157:18;:27::i;:::-;21236:17;21256:29;21269:7;21278:6;21256:12;:29::i;:::-;-1:-1:-1;;;;;21354:22:0;;21325:26;21354:22;;;:13;:22;;;;;21406:11;;21236:49;;-1:-1:-1;21354:22:0;21401:31;;21236:49;21401:4;:31::i;:::-;21387:11;:45;21462:11;;21457:31;;21475:12;21457:4;:31::i;:::-;21443:45;;21506:30;;;-1:-1:-1;;;;;21506:30:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21556:12:0;20992:584;-1:-1:-1;;;20992:584:0:o;18672:590::-;18730:10;18787:16;:14;:16::i;:::-;18814:27;18833:7;18814:18;:27::i;:::-;-1:-1:-1;;;;;18883:22:0;;;18854:26;18883:22;;;:13;:22;;;;;;;;18930:19;;;;19002:8;;:31;;-1:-1:-1;;;19002:31:0;;;;;;;;;;;;;;;;;18883:22;;18930:19;;;;19002:8;;;;;:14;;:31;;;;;18883:22;;19002:31;;;;;;;:8;:31;;;5:2:-1;;;;30:1;27;20:12;5:2;19002:31:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19002:31:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;19002:31:0;:41;18994:76;;;;;-1:-1:-1;;;18994:76:0;;;;;;;;;;;;-1:-1:-1;;;18994:76:0;;;;;;;;;;;;;;;19132:1;19110:19;;;:23;19173:21;;19168:35;;19196:6;19168:4;:35::i;:::-;19144:21;:59;19221:33;;;-1:-1:-1;;;;;19221:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;18672:590;;;:::o;17275:227::-;17311:4;17328:16;:14;:16::i;:::-;17360:32;17396:53;17418:10;17430:18;;17396:21;:53::i;:::-;17357:92;-1:-1:-1;;;17275:227:0;:::o;16339:846::-;16385:16;16404;:14;:16::i;:::-;16385:35;;16457:11;16435:18;;:33;16431:72;;;16485:7;;;16431:72;16515:29;16547:8;;;;;;;;;-1:-1:-1;;;;;16547:8:0;-1:-1:-1;;;;;16547:15:0;;:17;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;16547:17:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;16547:17:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;16547:17:0;16579:11;;16547:17;;-1:-1:-1;16575:102:0;;-1:-1:-1;16612:18:0;:32;16659:7;;16575:102;16689:10;16702:53;16707:24;16733:21;;16702:4;:53::i;:::-;16689:66;;16768:19;;:::i;:::-;16790:28;16799:5;16806:11;;16790:8;:28::i;:::-;16768:50;;16829:32;;:::i;:::-;16864:51;16869:38;;;;;;;;16887:18;;16869:38;;;16909:5;16864:4;:51::i;:::-;16987:27;;16966:18;:48;;;17025:21;:48;;;-1:-1:-1;17084:32:0;;;17134:43;;;;;;;;;;;;;;;16829:86;;-1:-1:-1;17134:43:0;;;;;;;;;16339:846;;;;;;:::o;17510:432::-;17576:10;17588:25;17617:50;17639:7;17648:18;;17617:21;:50::i;:::-;-1:-1:-1;;;;;17709:22:0;;17680:26;17709:22;;;:13;:22;;;;;;;;;17763:18;;;17742;;;:39;17792:19;;;:42;;;17915:18;17887:47;;;;;;;;;;;;;;;;;;;;17575:92;;-1:-1:-1;17575:92:0;;-1:-1:-1;17709:22:0;;17887:47;;;;;;;;;17510:432;;;;:::o;9387:120::-;9440:4;9464:35;9469:1;9472;9464:35;;;;;;;;;;;;;-1:-1:-1;;;9464:35:0;;;:4;:35::i;:::-;9457:42;9387:120;-1:-1:-1;;;9387:120:0:o;24943:894::-;25071:8;;25091:26;;;-1:-1:-1;;;25091:26:0;;-1:-1:-1;;;;;25091:26:0;;;;;;;;;;;;;;;25071:8;;;;;;;25091:14;;:26;;;;;25011:31;;25091:26;;;;;;;;25011:31;25071:8;25091:26;;;5:2:-1;;;;30:1;27;20:12;5:2;25091:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;25091:26:0;;;;25130:12;25184:16;25223:1;25218:152;;;;25393:2;25388:219;;;;25742:1;25739;25732:12;25218:152;-1:-1:-1;;25313:6:0;-1:-1:-1;25218:152:0;;25388:219;25490:2;25487:1;25484;25469:24;25532:1;25526:8;25515:19;;25177:586;;25792:7;25784:45;;;;;-1:-1:-1;;;25784:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;24943:894;;;;:::o;12183:147::-;12240:13;;:::i;:::-;12273:49;;;;;;;;12291:29;12296:20;12301:1;6021:4;12296;:20::i;:::-;12318:1;12291:4;:29::i;:::-;12273:49;;12266:56;12183:147;-1:-1:-1;;;12183:147:0:o;8584:160::-;8655:13;;:::i;:::-;8688:48;;;;;;;;8706:28;8711:1;:10;;;8723:1;:10;;;8706:4;:28::i;15574:757::-;15673:4;15679;15696:25;;:::i;:::-;-1:-1:-1;;;;;;15724:22:0;;;;;;:13;:22;;;;;;;;;15696:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15759:38;;:::i;:::-;-1:-1:-1;15800:42:0;;;;;;;;;;;;15853:39;;:::i;:::-;-1:-1:-1;15895:38:0;;;;;;;;;;15913:18;;;;15895:38;;;15948:39;:80;;;;-1:-1:-1;15991:33:0;;:37;;15948:80;15944:169;;;13280:4;16045:56;;15944:169;16125:24;;:::i;:::-;16152:57;16157:24;16183:25;16152:4;:57::i;:::-;16125:84;;16220:10;16233:29;16238:5;:11;;;16251:10;16233:4;:29::i;:::-;16220:42;;16283:5;16290:32;16295:5;:19;;;16316:5;16290:4;:32::i;:::-;16275:48;;;;;;;;;15574:757;;;;;:::o;8752:116::-;8805:4;8829:31;8834:1;8837;8829:31;;;;;;;;;;;;;-1:-1:-1;;;8829:31:0;;;:4;:31::i;22901:1338::-;23045:8;;23086:49;;;-1:-1:-1;;;23086:49:0;;23129:4;23086:49;;;;;;22968:4;;-1:-1:-1;;;;;23045:8:0;;22968:4;;23045:8;;23086:34;;:49;;;;;;;;;;;;;;23045:8;23086:49;;;5:2:-1;;;;30:1;27;20:12;5:2;23086:49:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23086:49:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;23086:49:0;23146:47;;;-1:-1:-1;;;23146:47:0;;-1:-1:-1;;;;;23146:47:0;;;;;;;23179:4;23146:47;;;;;;;;;;;;23086:49;;-1:-1:-1;23146:18:0;;;;;;:47;;;;;-1:-1:-1;;23146:47:0;;;;;;;;-1:-1:-1;23146:18:0;:47;;;5:2:-1;;;;30:1;27;20:12;5:2;23146:47:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23146:47:0;;;;23206:12;23260:16;23299:1;23294:153;;;;23470:2;23465:220;;;;23821:1;23818;23811:12;23294:153;-1:-1:-1;;23390:6:0;-1:-1:-1;23294:153:0;;23465:220;23568:2;23565:1;23562;23547:24;23610:1;23604:8;23593:19;;23253:589;;23871:7;23863:44;;;;;-1:-1:-1;;;23863:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;24020:8;;24005:49;;;-1:-1:-1;;;24005:49:0;;24048:4;24005:49;;;;;;23985:17;;-1:-1:-1;;;;;24020:8:0;;24005:34;;:49;;;;;;;;;;;;;;24020:8;24005:49;;;5:2:-1;;;;30:1;27;20:12;5:2;24005:49:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24005:49:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24005:49:0;;-1:-1:-1;24073:29:0;;;;24065:68;;;;;-1:-1:-1;;;24065:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;24151:28;;;;;22901:1338;-1:-1:-1;;;;;22901:1338:0:o;9515:158::-;9596:4;9629:12;9621:6;;;;9613:29;;;;-1:-1:-1;;;9613:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;9613:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9660:5:0;;;9515:158::o;10585:122::-;10638:4;10662:37;10667:1;10670;10662:37;;;;;;;;;;;;;;;;;:4;:37::i;11897:113::-;11950:4;11974:28;11979:1;11982;11974:28;;;;;;;;;;;;;-1:-1:-1;;;11974:28:0;;;:4;:28::i;9219:160::-;9290:13;;:::i;:::-;9323:48;;;;;;;;9341:28;9346:1;:10;;;9358:1;:10;;;9341:4;:28::i;10450:127::-;10512:4;6021;10536:19;10541:1;10544;:10;;;10536:4;:19::i;:::-;:33;;;;;;;10450:127;-1:-1:-1;;;10450:127:0:o;8876:179::-;8957:4;8983:5;;;9015:12;9007:6;;;;8999:29;;;;-1:-1:-1;;;8999:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;8999:29:0;-1:-1:-1;9046:1:0;8876:179;-1:-1:-1;;;;8876:179:0:o;10715:250::-;10796:4;10817:6;;;:16;;-1:-1:-1;10827:6:0;;10817:16;10813:57;;;-1:-1:-1;10857:1:0;10850:8;;10813:57;10889:5;;;10893:1;10889;:5;:1;10913:5;;;;;:10;10925:12;10905:33;;;;;-1:-1:-1;;;10905:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;12018:157:0;12099:4;12131:12;12124:5;12116:28;;;;-1:-1:-1;;;12116:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;12116:28:0;;12166:1;12162;:5;;;;;;;12018:157;-1:-1:-1;;;;12018:157:0:o;20149:5691::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;:::o

bzzr://dac5197a4889a2595bbf81d81f1b10e73268a79cef35fac69f386c8e410db20a