Contract 0x42Cbe17335ef8d52F8d1e0a261eA2e78E829C56e

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

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);
    
    function decimals() external view returns (uint8);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin/contracts/math/SafeMath.sol

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/utils/Address.sol

pragma solidity ^0.6.2;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol

pragma solidity ^0.6.0;

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts/GSN/Context.sol

pragma solidity ^0.6.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol

pragma solidity ^0.6.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * Returns the address of the current owner.
     */
    function governance() public view returns (address) {
        return _owner;
    }

    /**
     * Throws if called by any account other than the owner.
     */
    modifier onlyGovernance() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferGovernance(address newOwner) internal virtual onlyGovernance {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: contracts/Treasury.sol

pragma solidity ^0.6.6;

// Treasury Furnace is a simple vault for all the withdrawal fees sent to it and is a furnace for STBZ tokens
// When a user wants to take from the Treasury, they will simply have to burn their STBZ tokens into the treasury
// And they will redeem the percentage compared to the circulating number of STBZ tokens (total - operator - treasury)
// STBZ tokens stored in the treasury are effectively burned and cannot be redeemed again
// If this treasury is replaced in the future, future contracts will need to account for the burned tokens in this contract

contract StabilizeTreasuryFurnace is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    
    // variables
    address public stbzAddress; // The address for the STBZ tokens
    address public operatorAddress; // The address for the operator contract
    IERC20 private _stabilizeT; // Instance of stabilize token
    address[] private activeTokens; // A list of all the acceptable reward tokens to this treasury
    address[] public furnaceList; // A list of all the furnaces used previously

    // Events
    event TreasuryBurn(address indexed user, uint256 amount);

    constructor(
        address _stbz,
        address _operator
    ) public {
        stbzAddress = _stbz;
        operatorAddress = _operator;
        _stabilizeT = IERC20(stbzAddress);
        initialTokens();
        initialFurnaces();
    }
    
    // Initial operations
    function initialTokens() internal {
        // Testnet
        /*
        activeTokens.push(address(0xFf795577d9AC8bD7D90Ee22b6C1703490b6512FD)); // DAI
        activeTokens.push(address(0xe22da380ee6B445bb8273C81944ADEB6E8450422)); // USDC
        activeTokens.push(address(0x13512979ADE267AB5100878E2e0f485B568328a4)); // USDT
        activeTokens.push(address(0xD868790F57B39C9B2B51b12de046975f986675f9)); // sUSD
        */
        
        // Mainnet
        activeTokens.push(address(0x6B175474E89094C44Da98b954EedeAC495271d0F)); // DAI
        activeTokens.push(address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48)); // USDC
        activeTokens.push(address(0xdAC17F958D2ee523a2206206994597C13D831ec7)); // USDT
        activeTokens.push(address(0x57Ab1ec28D129707052df4dF418D58a2D46d5f51)); // sUSD
    }
    
    function initialFurnaces() internal {
        // Testnet
        //furnaceList.push(address(0x0B5F5ECeA3835a5C5f6F528353fae50c75B60c3e)); // Treasury #1
        //furnaceList.push(address(0x81C878E0B9261622192183415969a00dA12685ef)); // Treasury #2
        
        // Mainnet
        // None yet
    }

    
    // functions
    function circulatingSupply() public view returns (uint256) {
        if(_stabilizeT.totalSupply() == 0){
            return 0;
        }else{
            // Circulating supply is total supply minus operator contract minus treasury account
            uint256 total = _stabilizeT.totalSupply().sub(_stabilizeT.balanceOf(operatorAddress)).sub(_stabilizeT.balanceOf(address(this)));
            // Now factor in all previous furnaces
            if(furnaceList.length > 0){
                for(uint256 i = 0; i < furnaceList.length; i++){
                    total = total.sub(_stabilizeT.balanceOf(furnaceList[i]));
                }
            }
            return total;
        }
    }
    
    function totalTokens() external view returns (uint256) {
        return activeTokens.length;
    }
    
    function getTokenAddress(uint256 _pos) external view returns (address) {
        return activeTokens[_pos];
    }
    
    function getTokenBalance(uint256 _pos) external view returns (uint256) {
        IERC20 token = IERC20(activeTokens[_pos]);
        return token.balanceOf(address(this));
    }

    function claim(uint256 amount) external {
        require(amount > 0, "Cannot claim with 0 amount");
        require(activeTokens.length > 0, "There are no redeemable tokens in the treasury");
        uint256 supply = circulatingSupply(); // Get the current circulating supply before burning this token into treasury
        require(supply > 0, "There are no circulating tokens");
        _stabilizeT.safeTransferFrom(_msgSender(), address(this), amount);
        
        // Now process the treasury funds for each token
        uint256 i = 0;
        uint256 transferAmount = 0;
        for(i = 0; i < activeTokens.length; i++){
            IERC20 token = IERC20(activeTokens[i]);
            transferAmount = amount.mul(token.balanceOf(address(this))).div(supply);
            if(transferAmount > 0){
                token.safeTransfer(_msgSender(), transferAmount);
            }
        }
        
        emit TreasuryBurn(_msgSender(), amount);
    }
    
    // Governance only functions
    
    // Timelock variables
    // Timelock doesn't activate until someone has burned tokens to this address
    
    uint256 private _timelockStart; // The start of the timelock to change governance variables
    uint256 private _timelockType; // The function that needs to be changed
    uint256 constant _timelockDuration = 86400; // Timelock is 24 hours
    
    // Reusable timelock variables
    address private _timelock_address;
    
    modifier timelockConditionsMet(uint256 _type) {
        require(_timelockType == _type, "Timelock not acquired for this function");
        _timelockType = 0; // Reset the type once the timelock is used
        if(_stabilizeT.balanceOf(address(this)) > 0){
            // Timelock is only required after tokens burned into contract
            require(now >= _timelockStart + _timelockDuration, "Timelock time not met");
        }
        _;
    }
    
    // Change the owner of the token contract
    // --------------------
    function startGovernanceChange(address _address) external onlyGovernance {
        _timelockStart = now;
        _timelockType = 1;
        _timelock_address = _address;       
    }
    
    function finishGovernanceChange() external onlyGovernance timelockConditionsMet(1) {
        transferGovernance(_timelock_address);
    }
    // --------------------
   
    // Add a new token to the treasury
    // --------------------
    function startAddNewToken(address _address) external onlyGovernance {
        // Prevent the possibility of adding the burnt tokens as rewards
        require(_address != stbzAddress, "Cannot add token that is the same as the burnt tokens");
        _timelockStart = now;
        _timelockType = 2;
        _timelock_address = _address;
    }
    
    function finishAddNewToken() public onlyGovernance timelockConditionsMet(2) {
        // This adds a new tokens
        activeTokens.push(_timelock_address);
    }
    // --------------------
    
    // Select a token to remove from treasury discovery
    // --------------------
    function startRemoveToken(address _address) external onlyGovernance {
        _timelockStart = now;
        _timelockType = 3;
        _timelock_address = _address;
    }
    
    function finishRemoveToken() external onlyGovernance timelockConditionsMet(3) {
        uint256 length = activeTokens.length;
        for(uint256 i = 0; i < length; i++){
            if(activeTokens[i] == _timelock_address){
                // Move all the remaining elements down one
                for(uint256 i2 = i; i2 < length-1; i2++){
                    activeTokens[i2] = activeTokens[i2 + 1]; // Shift the data down one
                }
                activeTokens.pop(); //Remove last element
                break;
            }
        }
    }
    // --------------------
    
    // Add a new furnace to treasury
    // --------------------
    function startAddNewFurnace(address _address) external onlyGovernance {
        // Prevent the possibility of adding the burnt tokens as rewards
        require(_address != stbzAddress, "Cannot add STBZ address as a furnace");
        _timelockStart = now;
        _timelockType = 4;
        _timelock_address = _address;
    }
    
    function finishAddNewFurnace() public onlyGovernance timelockConditionsMet(4) {
        // This adds a new furnace
        furnaceList.push(_timelock_address);
    }
    // --------------------
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_stbz","type":"address"},{"internalType":"address","name":"_operator","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TreasuryBurn","type":"event"},{"inputs":[],"name":"circulatingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"finishAddNewFurnace","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"finishAddNewToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"finishGovernanceChange","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"finishRemoveToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"furnaceList","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pos","type":"uint256"}],"name":"getTokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pos","type":"uint256"}],"name":"getTokenBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"startAddNewFurnace","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"startAddNewToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"startGovernanceChange","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"startRemoveToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stbzAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

608060405234801561001057600080fd5b5060405162001c6538038062001c658339818101604052604081101561003557600080fd5b50805160209091015160006100516001600160e01b0361010016565b600080546001600160a01b0319166001600160a01b0383169081178255604051929350917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a350600180546001600160a01b038085166001600160a01b03199283161792839055600280548583169084161790556003805490921692169190911790556100e86001600160e01b0361010416565b6100f96001600160e01b036101d116565b50506101d3565b3390565b600480546001818101835560008390527f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b91820180546001600160a01b0319908116736b175474e89094c44da98b954eedeac495271d0f179091558354808301855583018054821673a0b86991c6218b36c1d19d4a2e9eb0ce3606eb481790558354808301855583018054821673dac17f958d2ee523a2206206994597c13d831ec717905583549182019093550180549091167357ab1ec28d129707052df4df418d58a2d46d5f51179055565b565b611a8280620001e36000396000f3fe608060405234801561001057600080fd5b506004361061010b5760003560e01c806367ccdf38116100a25780639358928b116100715780639358928b14610230578063b658183414610238578063b919507214610240578063dac7992f14610248578063f80087761461026e5761010b565b806367ccdf38146101d4578063795bd3a5146101f15780637e1c0c09146101f95780639105d748146102135761010b565b80635aa6e675116100de5780635aa6e675146101965780635b56d9191461019e57806360abbebc146101a6578063675016d1146101cc5761010b565b8063090c3dec14610110578063127effb21461014957806313baa18214610151578063379607f514610179575b600080fd5b61012d6004803603602081101561012657600080fd5b5035610294565b604080516001600160a01b039092168252519081900360200190f35b61012d6102bb565b6101776004803603602081101561016757600080fd5b50356001600160a01b03166102ca565b005b6101776004803603602081101561018f57600080fd5b503561039a565b61012d6105f5565b610177610605565b610177600480360360208110156101bc57600080fd5b50356001600160a01b03166107cc565b61017761084f565b61012d600480360360208110156101ea57600080fd5b5035610abb565b610177610ae5565b610201610cac565b60408051918252519081900360200190f35b6102016004803603602081101561022957600080fd5b5035610cb2565b610201610d47565b61012d611023565b610177611032565b6101776004803603602081101561025e57600080fd5b50356001600160a01b03166111bc565b6101776004803603602081101561028457600080fd5b50356001600160a01b031661128c565b600581815481106102a157fe5b6000918252602090912001546001600160a01b0316905081565b6002546001600160a01b031681565b6102d261130f565b6000546001600160a01b03908116911614610322576040805162461bcd60e51b815260206004820181905260248201526000805160206119df833981519152604482015290519081900360640190fd5b6001546001600160a01b038281169116141561036f5760405162461bcd60e51b815260040180806020018281038252603581526020018061193c6035913960400191505060405180910390fd5b426006556002600755600880546001600160a01b0319166001600160a01b0392909216919091179055565b600081116103ef576040805162461bcd60e51b815260206004820152601a60248201527f43616e6e6f7420636c61696d2077697468203020616d6f756e74000000000000604482015290519081900360640190fd5b60045461042d5760405162461bcd60e51b815260040180806020018281038252602e81526020018061190e602e913960400191505060405180910390fd5b6000610437610d47565b90506000811161048e576040805162461bcd60e51b815260206004820152601f60248201527f546865726520617265206e6f2063697263756c6174696e6720746f6b656e7300604482015290519081900360640190fd5b6104b361049961130f565b6003546001600160a01b031690308563ffffffff61131316565b6000805b6004548210156105a7576000600483815481106104d057fe5b60009182526020918290200154604080516370a0823160e01b815230600482015290516001600160a01b0390921693506105719287926105659286926370a0823192602480840193829003018186803b15801561052c57600080fd5b505afa158015610540573d6000803e3d6000fd5b505050506040513d602081101561055657600080fd5b5051889063ffffffff61137316565b9063ffffffff6113d516565b9150811561059b5761059b61058461130f565b6001600160a01b038316908463ffffffff61141716565b506001909101906104b7565b6105af61130f565b6001600160a01b03167fbdaa7e26da04c236a51f7305c19861187a6dea47e37342c3aabba42a56ea802a856040518082815260200191505060405180910390a250505050565b6000546001600160a01b03165b90565b61060d61130f565b6000546001600160a01b0390811691161461065d576040805162461bcd60e51b815260206004820181905260248201526000805160206119df833981519152604482015290519081900360640190fd5b6002806007541461069f5760405162461bcd60e51b81526004018080602001828103825260278152602001806119976027913960400191505060405180910390fd5b60006007819055600354604080516370a0823160e01b815230600482015290516001600160a01b03909216916370a0823191602480820192602092909190829003018186803b1580156106f157600080fd5b505afa158015610705573d6000803e3d6000fd5b505050506040513d602081101561071b57600080fd5b50511115610777576201518060065401421015610777576040805162461bcd60e51b8152602060048201526015602482015274151a5b595b1bd8dac81d1a5b59481b9bdd081b595d605a1b604482015290519081900360640190fd5b50600854600480546001810182556000919091527f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b0180546001600160a01b0319166001600160a01b03909216919091179055565b6107d461130f565b6000546001600160a01b03908116911614610824576040805162461bcd60e51b815260206004820181905260248201526000805160206119df833981519152604482015290519081900360640190fd5b426006556003600755600880546001600160a01b0319166001600160a01b0392909216919091179055565b61085761130f565b6000546001600160a01b039081169116146108a7576040805162461bcd60e51b815260206004820181905260248201526000805160206119df833981519152604482015290519081900360640190fd5b600380600754146108e95760405162461bcd60e51b81526004018080602001828103825260278152602001806119976027913960400191505060405180910390fd5b60006007819055600354604080516370a0823160e01b815230600482015290516001600160a01b03909216916370a0823191602480820192602092909190829003018186803b15801561093b57600080fd5b505afa15801561094f573d6000803e3d6000fd5b505050506040513d602081101561096557600080fd5b505111156109c15762015180600654014210156109c1576040805162461bcd60e51b8152602060048201526015602482015274151a5b595b1bd8dac81d1a5b59481b9bdd081b595d605a1b604482015290519081900360640190fd5b60045460005b81811015610ab657600854600480546001600160a01b0390921691839081106109ec57fe5b6000918252602090912001546001600160a01b03161415610aae57805b60018303811015610a7b5760048160010181548110610a2457fe5b600091825260209091200154600480546001600160a01b039092169183908110610a4a57fe5b600091825260209091200180546001600160a01b0319166001600160a01b0392909216919091179055600101610a09565b506004805480610a8757fe5b600082815260209020810160001990810180546001600160a01b0319169055019055610ab6565b6001016109c7565b505050565b600060048281548110610aca57fe5b6000918252602090912001546001600160a01b031692915050565b610aed61130f565b6000546001600160a01b03908116911614610b3d576040805162461bcd60e51b815260206004820181905260248201526000805160206119df833981519152604482015290519081900360640190fd5b60048060075414610b7f5760405162461bcd60e51b81526004018080602001828103825260278152602001806119976027913960400191505060405180910390fd5b60006007819055600354604080516370a0823160e01b815230600482015290516001600160a01b03909216916370a0823191602480820192602092909190829003018186803b158015610bd157600080fd5b505afa158015610be5573d6000803e3d6000fd5b505050506040513d6020811015610bfb57600080fd5b50511115610c57576201518060065401421015610c57576040805162461bcd60e51b8152602060048201526015602482015274151a5b595b1bd8dac81d1a5b59481b9bdd081b595d605a1b604482015290519081900360640190fd5b50600854600580546001810182556000919091527f036b6384b5eca791c62761152d0c79bb0604c104a5fb6f4eb0703f3154bb3db00180546001600160a01b0319166001600160a01b03909216919091179055565b60045490565b60008060048381548110610cc257fe5b60009182526020918290200154604080516370a0823160e01b815230600482015290516001600160a01b03909216935083926370a0823192602480840193829003018186803b158015610d1457600080fd5b505afa158015610d28573d6000803e3d6000fd5b505050506040513d6020811015610d3e57600080fd5b50519392505050565b600354604080516318160ddd60e01b815290516000926001600160a01b0316916318160ddd916004808301926020929190829003018186803b158015610d8c57600080fd5b505afa158015610da0573d6000803e3d6000fd5b505050506040513d6020811015610db657600080fd5b5051610dc457506000610602565b600354604080516370a0823160e01b81523060048201529051600092610f4c926001600160a01b03909116916370a0823191602480820192602092909190829003018186803b158015610e1657600080fd5b505afa158015610e2a573d6000803e3d6000fd5b505050506040513d6020811015610e4057600080fd5b5051600354600254604080516370a0823160e01b81526001600160a01b0392831660048201529051610f409392909216916370a0823191602480820192602092909190829003018186803b158015610e9757600080fd5b505afa158015610eab573d6000803e3d6000fd5b505050506040513d6020811015610ec157600080fd5b5051600354604080516318160ddd60e01b815290516001600160a01b03909216916318160ddd91600480820192602092909190829003018186803b158015610f0857600080fd5b505afa158015610f1c573d6000803e3d6000fd5b505050506040513d6020811015610f3257600080fd5b50519063ffffffff61146916565b9063ffffffff61146916565b6005549091501561101c5760005b60055481101561101a5760035460058054611010926001600160a01b0316916370a082319185908110610f8957fe5b60009182526020918290200154604080516001600160e01b031960e086901b1681526001600160a01b0390921660048301525160248083019392829003018186803b158015610fd757600080fd5b505afa158015610feb573d6000803e3d6000fd5b505050506040513d602081101561100157600080fd5b5051839063ffffffff61146916565b9150600101610f5a565b505b9050610602565b6001546001600160a01b031681565b61103a61130f565b6000546001600160a01b0390811691161461108a576040805162461bcd60e51b815260206004820181905260248201526000805160206119df833981519152604482015290519081900360640190fd5b600180600754146110cc5760405162461bcd60e51b81526004018080602001828103825260278152602001806119976027913960400191505060405180910390fd5b60006007819055600354604080516370a0823160e01b815230600482015290516001600160a01b03909216916370a0823191602480820192602092909190829003018186803b15801561111e57600080fd5b505afa158015611132573d6000803e3d6000fd5b505050506040513d602081101561114857600080fd5b505111156111a45762015180600654014210156111a4576040805162461bcd60e51b8152602060048201526015602482015274151a5b595b1bd8dac81d1a5b59481b9bdd081b595d605a1b604482015290519081900360640190fd5b6008546111b9906001600160a01b03166114ab565b50565b6111c461130f565b6000546001600160a01b03908116911614611214576040805162461bcd60e51b815260206004820181905260248201526000805160206119df833981519152604482015290519081900360640190fd5b6001546001600160a01b03828116911614156112615760405162461bcd60e51b81526004018080602001828103825260248152602001806119ff6024913960400191505060405180910390fd5b426006556004600755600880546001600160a01b0319166001600160a01b0392909216919091179055565b61129461130f565b6000546001600160a01b039081169116146112e4576040805162461bcd60e51b815260206004820181905260248201526000805160206119df833981519152604482015290519081900360640190fd5b426006556001600755600880546001600160a01b0319166001600160a01b0392909216919091179055565b3390565b604080516001600160a01b0380861660248301528416604482015260648082018490528251808303909101815260849091019091526020810180516001600160e01b03166323b872dd60e01b17905261136d9085906115a3565b50505050565b600082611382575060006113cf565b8282028284828161138f57fe5b04146113cc5760405162461bcd60e51b81526004018080602001828103825260218152602001806119be6021913960400191505060405180910390fd5b90505b92915050565b60006113cc83836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250611654565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b179052610ab69084906115a3565b60006113cc83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f7700008152506116f6565b6114b361130f565b6000546001600160a01b03908116911614611503576040805162461bcd60e51b815260206004820181905260248201526000805160206119df833981519152604482015290519081900360640190fd5b6001600160a01b0381166115485760405162461bcd60e51b81526004018080602001828103825260268152602001806119716026913960400191505060405180910390fd5b600080546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0319166001600160a01b0392909216919091179055565b60606115f8826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166117509092919063ffffffff16565b805190915015610ab65780806020019051602081101561161757600080fd5b5051610ab65760405162461bcd60e51b815260040180806020018281038252602a815260200180611a23602a913960400191505060405180910390fd5b600081836116e05760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b838110156116a557818101518382015260200161168d565b50505050905090810190601f1680156116d25780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b5060008385816116ec57fe5b0495945050505050565b600081848411156117485760405162461bcd60e51b81526020600482018181528351602484015283519092839260449091019190850190808383600083156116a557818101518382015260200161168d565b505050900390565b606061175f8484600085611767565b949350505050565b6060611772856118d4565b6117c3576040805162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015290519081900360640190fd5b60006060866001600160a01b031685876040518082805190602001908083835b602083106118025780518252601f1990920191602091820191016117e3565b6001836020036101000a03801982511681845116808217855250505050505090500191505060006040518083038185875af1925050503d8060008114611864576040519150601f19603f3d011682016040523d82523d6000602084013e611869565b606091505b5091509150811561187d57915061175f9050565b80511561188d5780518082602001fd5b60405162461bcd60e51b81526020600482018181528651602484015286518793919283926044019190850190808383600083156116a557818101518382015260200161168d565b6000813f7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47081811480159061175f57505015159291505056fe546865726520617265206e6f2072656465656d61626c6520746f6b656e7320696e2074686520747265617375727943616e6e6f742061646420746f6b656e2074686174206973207468652073616d6520617320746865206275726e7420746f6b656e734f776e61626c653a206e6577206f776e657220697320746865207a65726f206164647265737354696d656c6f636b206e6f7420616371756972656420666f7220746869732066756e6374696f6e536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f774f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657243616e6e6f7420616464205354425a20616464726573732061732061206675726e6163655361666545524332303a204552433230206f7065726174696f6e20646964206e6f742073756363656564a2646970667358221220d30272ea6564d6fbd0afff1cdfaa0a24bea7d4f125067cf2de5d1eba0db29bf364736f6c63430006060033000000000000000000000000b987d48ed8f2c468d52d6405624eadba5e76d723000000000000000000000000ee9156c93ebb836513968f92b4a67721f3cea08a

000000000000000000000000b987d48ed8f2c468d52d6405624eadba5e76d723000000000000000000000000ee9156c93ebb836513968f92b4a67721f3cea08a

-----Decoded View---------------
Arg [0] : _stbz (address): 0xb987d48ed8f2c468d52d6405624eadba5e76d723
Arg [1] : _operator (address): 0xee9156c93ebb836513968f92b4a67721f3cea08a

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000b987d48ed8f2c468d52d6405624eadba5e76d723
Arg [1] : 000000000000000000000000ee9156c93ebb836513968f92b4a67721f3cea08a

21623:7754:0:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;21623:7754:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;22075:28:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;22075:28:0;;:::i;:::-;;;;-1:-1:-1;;;;;22075:28:0;;;;;;;;;;;;;;21833:30;;;:::i;27314:348::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;27314:348:0;-1:-1:-1;;;;;27314:348:0;;:::i;:::-;;24847:976;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;24847:976:0;;:::i;20292:84::-;;;:::i;27674:166::-;;;:::i;27967:174::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;27967:174:0;-1:-1:-1;;;;;27967:174:0;;:::i;28153:571::-;;;:::i;24533:115::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;24533:115:0;;:::i;29177:168::-;;;:::i;24421:100::-;;;:::i;:::-;;;;;;;;;;;;;;;;24660:179;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;24660:179:0;;:::i;23708:701::-;;;:::i;21765:26::-;;;:::i;27066:139::-;;;:::i;28832:333::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;28832:333:0;-1:-1:-1;;;;;28832:333:0;;:::i;26868:186::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;26868:186:0;-1:-1:-1;;;;;26868:186:0;;:::i;22075:28::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22075:28:0;;-1:-1:-1;22075:28:0;:::o;21833:30::-;;;-1:-1:-1;;;;;21833:30:0;;:::o;27314:348::-;20519:12;:10;:12::i;:::-;20509:6;;-1:-1:-1;;;;;20509:6:0;;;:22;;;20501:67;;;;;-1:-1:-1;;;20501:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;20501:67:0;;;;;;;;;;;;;;;27487:11:::1;::::0;-1:-1:-1;;;;;27475:23:0;;::::1;27487:11:::0;::::1;27475:23;;27467:89;;;;-1:-1:-1::0;;;27467:89:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27584:3;27567:14;:20:::0;27614:1:::1;27598:13;:17:::0;27626::::1;:28:::0;;-1:-1:-1;;;;;;27626:28:0::1;-1:-1:-1::0;;;;;27626:28:0;;;::::1;::::0;;;::::1;::::0;;27314:348::o;24847:976::-;24915:1;24906:6;:10;24898:49;;;;;-1:-1:-1;;;24898:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;24966:12;:19;24958:82;;;;-1:-1:-1;;;24958:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25051:14;25068:19;:17;:19::i;:::-;25051:36;;25193:1;25184:6;:10;25176:54;;;;;-1:-1:-1;;;25176:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;25241:65;25270:12;:10;:12::i;:::-;25241:11;;-1:-1:-1;;;;;25241:11:0;;25292:4;25299:6;25241:65;:28;:65;:::i;:::-;25385:9;;25446:310;25461:12;:19;25457:23;;25446:310;;;25501:12;25523;25536:1;25523:15;;;;;;;;;;;;;;;;;;;25582:30;;;-1:-1:-1;;;25582:30:0;;25606:4;25582:30;;;;;;-1:-1:-1;;;;;25523:15:0;;;;-1:-1:-1;25571:54:0;;25618:6;;25571:42;;25523:15;;25582;;:30;;;;;;;;;;25523:15;25582:30;;;2:2:-1;;;;27:1;24;17:12;2:2;25582:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;25582:30:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;25582:30:0;25571:6;;:42;:10;:42;:::i;:::-;:46;:54;:46;:54;:::i;:::-;25554:71;-1:-1:-1;25643:18:0;;25640:105;;25681:48;25700:12;:10;:12::i;:::-;-1:-1:-1;;;;;25681:18:0;;;25714:14;25681:48;:18;:48;:::i;:::-;-1:-1:-1;25482:3:0;;;;;25446:310;;;25794:12;:10;:12::i;:::-;-1:-1:-1;;;;;25781:34:0;;25808:6;25781:34;;;;;;;;;;;;;;;;;;24847:976;;;;:::o;20292:84::-;20335:7;20362:6;-1:-1:-1;;;;;20362:6:0;20292:84;;:::o;27674:166::-;20519:12;:10;:12::i;:::-;20509:6;;-1:-1:-1;;;;;20509:6:0;;;:22;;;20501:67;;;;;-1:-1:-1;;;20501:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;20501:67:0;;;;;;;;;;;;;;;27747:1:::1;26407:5;26390:13;;:22;26382:74;;;;-1:-1:-1::0;;;26382:74:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26483:1;26467:13;:17:::0;;;26542:11:::1;::::0;:36:::1;::::0;;-1:-1:-1;;;26542:36:0;;26572:4:::1;26542:36;::::0;::::1;::::0;;;-1:-1:-1;;;;;26542:11:0;;::::1;::::0;:21:::1;::::0;:36;;;;;::::1;::::0;;;;;;;;;:11;:36;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;26542:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;26542:36:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;26542:36:0;:40:::1;26539:222;;;26201:5;26689:14;;:34;26682:3;:41;;26674:75;;;::::0;;-1:-1:-1;;;26674:75:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;26674:75:0;;;;;;;;;;;;;::::1;;-1:-1:-1::0;27814:17:0::2;::::0;27796:12:::2;27:10:-1::0;;27814:17:0;23:18:-1;::::2;45:23:::0;;27814:17:0::2;27796:36:::0;;;;;::::2;::::0;;-1:-1:-1;;;;;;27796:36:0::2;-1:-1:-1::0;;;;;27814:17:0;;::::2;27796:36:::0;;;::::2;::::0;;27674:166::o;27967:174::-;20519:12;:10;:12::i;:::-;20509:6;;-1:-1:-1;;;;;20509:6:0;;;:22;;;20501:67;;;;;-1:-1:-1;;;20501:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;20501:67:0;;;;;;;;;;;;;;;28063:3:::1;28046:14;:20:::0;28093:1:::1;28077:13;:17:::0;28105::::1;:28:::0;;-1:-1:-1;;;;;;28105:28:0::1;-1:-1:-1::0;;;;;28105:28:0;;;::::1;::::0;;;::::1;::::0;;27967:174::o;28153:571::-;20519:12;:10;:12::i;:::-;20509:6;;-1:-1:-1;;;;;20509:6:0;;;:22;;;20501:67;;;;;-1:-1:-1;;;20501:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;20501:67:0;;;;;;;;;;;;;;;28228:1:::1;26407:5;26390:13;;:22;26382:74;;;;-1:-1:-1::0;;;26382:74:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26483:1;26467:13;:17:::0;;;26542:11:::1;::::0;:36:::1;::::0;;-1:-1:-1;;;26542:36:0;;26572:4:::1;26542:36;::::0;::::1;::::0;;;-1:-1:-1;;;;;26542:11:0;;::::1;::::0;:21:::1;::::0;:36;;;;;::::1;::::0;;;;;;;;;:11;:36;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;26542:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;26542:36:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;26542:36:0;:40:::1;26539:222;;;26201:5;26689:14;;:34;26682:3;:41;;26674:75;;;::::0;;-1:-1:-1;;;26674:75:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;26674:75:0;;;;;;;;;;;;;::::1;;28259:12:::2;:19:::0;28242:14:::2;28289:428;28312:6;28308:1;:10;28289:428;;;28361:17;::::0;28342:12:::2;:15:::0;;-1:-1:-1;;;;;28361:17:0;;::::2;::::0;28355:1;;28342:15;::::2;;;;;;::::0;;;::::2;::::0;;;::::2;::::0;-1:-1:-1;;;;;28342:15:0::2;:36;28339:367;;;28476:1:::0;28459:149:::2;28491:1;28484:6;:8;28479:2;:13;28459:149;;;28541:12;28554:2;28559:1;28554:6;28541:20;;;;;;;;;::::0;;;::::2;::::0;;;::::2;::::0;28522:12:::2;:16:::0;;-1:-1:-1;;;;;28541:20:0;;::::2;::::0;28535:2;;28522:16;::::2;;;;;;::::0;;;::::2;::::0;;;::::2;:39:::0;;-1:-1:-1;;;;;;28522:39:0::2;-1:-1:-1::0;;;;;28522:39:0;;;::::2;::::0;;;::::2;::::0;;-1:-1:-1;28494:4:0::2;28459:149;;;;28626:12;:18;;;;;;;;::::0;;;::::2;::::0;;;;-1:-1:-1;;28626:18:0;;;;;-1:-1:-1;;;;;;28626:18:0::2;::::0;;;;;28685:5:::2;;28339:367;28320:3;;28289:428;;;;26771:1;20579::::1;28153:571::o:0;24533:115::-;24595:7;24622:12;24635:4;24622:18;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;24622:18:0;;24533:115;-1:-1:-1;;24533:115:0:o;29177:168::-;20519:12;:10;:12::i;:::-;20509:6;;-1:-1:-1;;;;;20509:6:0;;;:22;;;20501:67;;;;;-1:-1:-1;;;20501:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;20501:67:0;;;;;;;;;;;;;;;29252:1:::1;26407:5;26390:13;;:22;26382:74;;;;-1:-1:-1::0;;;26382:74:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26483:1;26467:13;:17:::0;;;26542:11:::1;::::0;:36:::1;::::0;;-1:-1:-1;;;26542:36:0;;26572:4:::1;26542:36;::::0;::::1;::::0;;;-1:-1:-1;;;;;26542:11:0;;::::1;::::0;:21:::1;::::0;:36;;;;;::::1;::::0;;;;;;;;;:11;:36;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;26542:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;26542:36:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;26542:36:0;:40:::1;26539:222;;;26201:5;26689:14;;:34;26682:3;:41;;26674:75;;;::::0;;-1:-1:-1;;;26674:75:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;26674:75:0;;;;;;;;;;;;;::::1;;-1:-1:-1::0;29319:17:0::2;::::0;29302:11:::2;27:10:-1::0;;29319:17:0;23:18:-1;::::2;45:23:::0;;29319:17:0::2;29302:35:::0;;;;;::::2;::::0;;-1:-1:-1;;;;;;29302:35:0::2;-1:-1:-1::0;;;;;29319:17:0;;::::2;29302:35:::0;;;::::2;::::0;;29177:168::o;24421:100::-;24494:12;:19;24421:100;:::o;24660:179::-;24722:7;24742:12;24764;24777:4;24764:18;;;;;;;;;;;;;;;;;;;24801:30;;;-1:-1:-1;;;24801:30:0;;24825:4;24801:30;;;;;;-1:-1:-1;;;;;24764:18:0;;;;-1:-1:-1;24764:18:0;;24801:15;;:30;;;;;;;;;;24764:18;24801:30;;;2:2:-1;;;;27:1;24;17:12;2:2;24801:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24801:30:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;24801:30:0;;24660:179;-1:-1:-1;;;24660:179:0:o;23708:701::-;23781:11;;:25;;;-1:-1:-1;;;23781:25:0;;;;23758:7;;-1:-1:-1;;;;;23781:11:0;;:23;;:25;;;;;;;;;;;;;;:11;:25;;;2:2:-1;;;;27:1;24;17:12;2:2;23781:25:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23781:25:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;23781:25:0;23778:624;;-1:-1:-1;23834:1:0;23827:8;;23778:624;24054:11;;:36;;;-1:-1:-1;;;24054:36:0;;24084:4;24054:36;;;;;;23964:13;;23980:111;;-1:-1:-1;;;;;24054:11:0;;;;:21;;:36;;;;;;;;;;;;;;;:11;:36;;;2:2:-1;;;;27:1;24;17:12;2:2;24054:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24054:36:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;24054:36:0;24010:11;;24032:15;;24010:38;;;-1:-1:-1;;;24010:38:0;;-1:-1:-1;;;;;24032:15:0;;;24010:38;;;;;;23980:69;;24010:11;;;;;:21;;:38;;;;;24054:36;;24010:38;;;;;;;;:11;:38;;;2:2:-1;;;;27:1;24;17:12;2:2;24010:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24010:38:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;24010:38:0;23980:11;;:25;;;-1:-1:-1;;;23980:25:0;;;;-1:-1:-1;;;;;23980:11:0;;;;:23;;:25;;;;;24010:38;;23980:25;;;;;;;;:11;:25;;;2:2:-1;;;;27:1;24;17:12;2:2;23980:25:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23980:25:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;23980:25:0;;:69;:29;:69;:::i;:::-;:73;:111;:73;:111;:::i;:::-;24161:11;:18;23964:127;;-1:-1:-1;24161:22:0;24158:206;;24207:9;24203:146;24226:11;:18;24222:22;;24203:146;;;24291:11;;24313;:14;;24281:48;;-1:-1:-1;;;;;24291:11:0;;:21;;24325:1;;24313:14;;;;;;;;;;;;;;;;;24291:37;;;-1:-1:-1;;;;;;24291:37:0;;;;;;;-1:-1:-1;;;;;24313:14:0;;;24291:37;;;;;;;;;;24313:14;24291:37;;;;;;;;;2:2:-1;;;;27:1;24;17:12;2:2;24291:37:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24291:37:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;24291:37:0;24281:5;;:48;:9;:48;:::i;:::-;24273:56;-1:-1:-1;24246:3:0;;24203:146;;;;24158:206;24385:5;-1:-1:-1;24378:12:0;;21765:26;;;-1:-1:-1;;;;;21765:26:0;;:::o;27066:139::-;20519:12;:10;:12::i;:::-;20509:6;;-1:-1:-1;;;;;20509:6:0;;;:22;;;20501:67;;;;;-1:-1:-1;;;20501:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;20501:67:0;;;;;;;;;;;;;;;27146:1:::1;26407:5;26390:13;;:22;26382:74;;;;-1:-1:-1::0;;;26382:74:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26483:1;26467:13;:17:::0;;;26542:11:::1;::::0;:36:::1;::::0;;-1:-1:-1;;;26542:36:0;;26572:4:::1;26542:36;::::0;::::1;::::0;;;-1:-1:-1;;;;;26542:11:0;;::::1;::::0;:21:::1;::::0;:36;;;;;::::1;::::0;;;;;;;;;:11;:36;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;26542:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;26542:36:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;26542:36:0;:40:::1;26539:222;;;26201:5;26689:14;;:34;26682:3;:41;;26674:75;;;::::0;;-1:-1:-1;;;26674:75:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;26674:75:0;;;;;;;;;;;;;::::1;;27179:17:::2;::::0;27160:37:::2;::::0;-1:-1:-1;;;;;27179:17:0::2;27160:18;:37::i;:::-;20579:1:::1;27066:139::o:0;28832:333::-;20519:12;:10;:12::i;:::-;20509:6;;-1:-1:-1;;;;;20509:6:0;;;:22;;;20501:67;;;;;-1:-1:-1;;;20501:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;20501:67:0;;;;;;;;;;;;;;;29007:11:::1;::::0;-1:-1:-1;;;;;28995:23:0;;::::1;29007:11:::0;::::1;28995:23;;28987:72;;;;-1:-1:-1::0;;;28987:72:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29087:3;29070:14;:20:::0;29117:1:::1;29101:13;:17:::0;29129::::1;:28:::0;;-1:-1:-1;;;;;;29129:28:0::1;-1:-1:-1::0;;;;;29129:28:0;;;::::1;::::0;;;::::1;::::0;;28832:333::o;26868:186::-;20519:12;:10;:12::i;:::-;20509:6;;-1:-1:-1;;;;;20509:6:0;;;:22;;;20501:67;;;;;-1:-1:-1;;;20501:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;20501:67:0;;;;;;;;;;;;;;;26969:3:::1;26952:14;:20:::0;26999:1:::1;26983:13;:17:::0;27011::::1;:28:::0;;-1:-1:-1;;;;;;27011:28:0::1;-1:-1:-1::0;;;;;27011:28:0;;;::::1;::::0;;;::::1;::::0;;26868:186::o;18858:106::-;18946:10;18858:106;:::o;15348:205::-;15476:68;;;-1:-1:-1;;;;;15476:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;15476:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;15449:96:0;;15469:5;;15449:19;:96::i;:::-;15348:205;;;;:::o;5169:471::-;5227:7;5472:6;5468:47;;-1:-1:-1;5502:1:0;5495:8;;5468:47;5539:5;;;5543:1;5539;:5;:1;5563:5;;;;;:10;5555:56;;;;-1:-1:-1;;;5555:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5631:1;-1:-1:-1;5169:471:0;;;;;:::o;6116:132::-;6174:7;6201:39;6205:1;6208;6201:39;;;;;;;;;;;;;;;;;:3;:39::i;15163:177::-;15273:58;;;-1:-1:-1;;;;;15273:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;15273:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;15246:86:0;;15266:5;;15246:19;:86::i;4279:136::-;4337:7;4364:43;4368:1;4371;4364:43;;;;;;;;;;;;;;;;;:3;:43::i;20738:252::-;20519:12;:10;:12::i;:::-;20509:6;;-1:-1:-1;;;;;20509:6:0;;;:22;;;20501:67;;;;;-1:-1:-1;;;20501:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;20501:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;20835:22:0;::::1;20827:73;;;;-1:-1:-1::0;;;20827:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20937:6;::::0;;20916:38:::1;::::0;-1:-1:-1;;;;;20916:38:0;;::::1;::::0;20937:6;::::1;::::0;20916:38:::1;::::0;::::1;20965:6;:17:::0;;-1:-1:-1;;;;;;20965:17:0::1;-1:-1:-1::0;;;;;20965:17:0;;;::::1;::::0;;;::::1;::::0;;20738:252::o;17468:761::-;17892:23;17918:69;17946:4;17918:69;;;;;;;;;;;;;;;;;17926:5;-1:-1:-1;;;;;17918:27:0;;;:69;;;;;:::i;:::-;18002:17;;17892:95;;-1:-1:-1;18002:21:0;17998:224;;18144:10;18133:30;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;18133:30:0;18125:85;;;;-1:-1:-1;;;18125:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6744:278;6830:7;6865:12;6858:5;6850:28;;;;-1:-1:-1;;;6850:28: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;6850:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6889:9;6905:1;6901;:5;;;;;;;6744:278;-1:-1:-1;;;;;6744:278:0:o;4718:192::-;4804:7;4840:12;4832:6;;;;4824:29;;;;-1:-1:-1;;;4824:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;4824:29:0;-1:-1:-1;;;4876:5:0;;;4718:192::o;12152:196::-;12255:12;12287:53;12310:6;12318:4;12324:1;12327:12;12287:22;:53::i;:::-;12280:60;12152:196;-1:-1:-1;;;;12152:196:0:o;13529:979::-;13659:12;13692:18;13703:6;13692:10;:18::i;:::-;13684:60;;;;;-1:-1:-1;;;13684:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;13818:12;13832:23;13859:6;-1:-1:-1;;;;;13859:11:0;13879:8;13890:4;13859:36;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;13859:36:0;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;13817:78:0;;;;13910:7;13906:595;;;13941:10;-1:-1:-1;13934:17:0;;-1:-1:-1;13934:17:0;13906:595;14055:17;;:21;14051:439;;14318:10;14312:17;14379:15;14366:10;14362:2;14358:19;14351:44;14266:148;14454:20;;-1:-1:-1;;;14454:20:0;;;;;;;;;;;;;;;;;14461:12;;14454:20;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;9037:619:0;9097:4;9565:20;;9408:66;9605:23;;;;;;:42;;-1:-1:-1;;9632:15:0;;;9597:51;-1:-1:-1;;9037:619:0:o

ipfs://d30272ea6564d6fbd0afff1cdfaa0a24bea7d4f125067cf2de5d1eba0db29bf3