Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-01-22
*/

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

pragma solidity ^0.5.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.
     *
     * _Available since v2.4.0._
     */
    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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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

pragma solidity ^0.5.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.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view 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/ownership/Ownable.sol

pragma solidity ^0.5.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.
 *
 * 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);

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

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

pragma solidity ^0.5.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 *
 * _Since v2.5.0:_ this module is now much more gas efficient, given net gas
 * metering changes introduced in the Istanbul hardfork.
 */
contract ReentrancyGuard {
    bool private _notEntered;

    constructor () internal {
        // Storing an initial non-zero value makes deployment a bit more
        // expensive, but in exchange the refund on every call to nonReentrant
        // will be lower in amount. Since refunds are capped to a percetange of
        // the total transaction's gas, it is best to keep them low in cases
        // like this one, to increase the likelihood of the full refund coming
        // into effect.
        _notEntered = true;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_notEntered, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _notEntered = false;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _notEntered = true;
    }
}

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

pragma solidity ^0.5.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

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

pragma solidity ^0.5.0;


/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
   /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (array[mid] > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && array[low - 1] == element) {
            return low - 1;
        } else {
            return low;
        }
    }
}

// File: @openzeppelin/contracts/drafts/Counters.sol

pragma solidity ^0.5.0;


/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath}
 * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
 * directly accessed.
 */
library Counters {
    using SafeMath for uint256;

    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        // The {SafeMath} overflow check can be skipped here, see the comment at the top
        counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        counter._value = counter._value.sub(1);
    }
}

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

pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @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/token/ERC20/ERC20.sol

pragma solidity ^0.5.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20Mintable}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }
}

// File: @openzeppelin/contracts/drafts/ERC20Snapshot.sol

pragma solidity ^0.5.0;





/**
 * @title ERC20 token with snapshots.
 * @dev Inspired by Jordi Baylina's
 * https://github.com/Giveth/minimd/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol[MiniMeToken]
 * to record historical balances.
 *
 * When a snapshot is made, the balances and total supply at the time of the snapshot are recorded for later
 * access.
 *
 * To make a snapshot, call the {snapshot} function, which will emit the {Snapshot} event and return a snapshot id.
 * To get the total supply from a snapshot, call the function {totalSupplyAt} with the snapshot id.
 * To get the balance of an account from a snapshot, call the {balanceOfAt} function with the snapshot id and the
 * account address.
 * @author Validity Labs AG <info@validitylabs.org>
 */
contract ERC20Snapshot is ERC20 {
    using SafeMath for uint256;
    using Arrays for uint256[];
    using Counters for Counters.Counter;

    // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
    // Snapshot struct, but that would impede usage of functions that work on an array.
    struct Snapshots {
        uint256[] ids;
        uint256[] values;
    }

    mapping (address => Snapshots) private _accountBalanceSnapshots;
    Snapshots private _totalSupplySnapshots;

    // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
    Counters.Counter private _currentSnapshotId;

    event Snapshot(uint256 id);

    // Creates a new snapshot id. Balances are only stored in snapshots on demand: unless a snapshot was taken, a
    // balance change will not be recorded. This means the extra added cost of storing snapshotted balances is only paid
    // when required, but is also flexible enough that it allows for e.g. daily snapshots.
    function snapshot() public returns (uint256) {
        _currentSnapshotId.increment();

        uint256 currentId = _currentSnapshotId.current();
        emit Snapshot(currentId);
        return currentId;
    }

    function balanceOfAt(address account, uint256 snapshotId) public view returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);

        return snapshotted ? value : balanceOf(account);
    }

    function totalSupplyAt(uint256 snapshotId) public view returns(uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);

        return snapshotted ? value : totalSupply();
    }

    // _transfer, _mint and _burn are the only functions where the balances are modified, so it is there that the
    // snapshots are updated. Note that the update happens _before_ the balance change, with the pre-modified value.
    // The same is true for the total supply and _mint and _burn.
    function _transfer(address from, address to, uint256 value) internal {
        _updateAccountSnapshot(from);
        _updateAccountSnapshot(to);

        super._transfer(from, to, value);
    }

    function _mint(address account, uint256 value) internal {
        _updateAccountSnapshot(account);
        _updateTotalSupplySnapshot();

        super._mint(account, value);
    }

    function _burn(address account, uint256 value) internal {
        _updateAccountSnapshot(account);
        _updateTotalSupplySnapshot();

        super._burn(account, value);
    }

    // When a valid snapshot is queried, there are three possibilities:
    //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
    //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
    //  to this id is the current one.
    //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
    //  requested id, and its value is the one to return.
    //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
    //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
    //  larger than the requested one.
    //
    // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
    // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
    // exactly this.
    function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
        private view returns (bool, uint256)
    {
        require(snapshotId > 0, "ERC20Snapshot: id is 0");
        // solhint-disable-next-line max-line-length
        require(snapshotId <= _currentSnapshotId.current(), "ERC20Snapshot: nonexistent id");

        uint256 index = snapshots.ids.findUpperBound(snapshotId);

        if (index == snapshots.ids.length) {
            return (false, 0);
        } else {
            return (true, snapshots.values[index]);
        }
    }

    function _updateAccountSnapshot(address account) private {
        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
    }

    function _updateTotalSupplySnapshot() private {
        _updateSnapshot(_totalSupplySnapshots, totalSupply());
    }

    function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
        uint256 currentId = _currentSnapshotId.current();
        if (_lastSnapshotId(snapshots.ids) < currentId) {
            snapshots.ids.push(currentId);
            snapshots.values.push(currentValue);
        }
    }

    function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
        if (ids.length == 0) {
            return 0;
        } else {
            return ids[ids.length - 1];
        }
    }
}

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

pragma solidity ^0.5.0;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev See {ERC20-_burnFrom}.
     */
    function burnFrom(address account, uint256 amount) public {
        _burnFrom(account, amount);
    }
}

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

pragma solidity ^0.5.0;

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
    struct Role {
        mapping (address => bool) bearer;
    }

    /**
     * @dev Give an account access to this role.
     */
    function add(Role storage role, address account) internal {
        require(!has(role, account), "Roles: account already has role");
        role.bearer[account] = true;
    }

    /**
     * @dev Remove an account's access to this role.
     */
    function remove(Role storage role, address account) internal {
        require(has(role, account), "Roles: account does not have role");
        role.bearer[account] = false;
    }

    /**
     * @dev Check if an account has this role.
     * @return bool
     */
    function has(Role storage role, address account) internal view returns (bool) {
        require(account != address(0), "Roles: account is the zero address");
        return role.bearer[account];
    }
}

// File: @openzeppelin/contracts/access/roles/MinterRole.sol

pragma solidity ^0.5.0;



contract MinterRole is Context {
    using Roles for Roles.Role;

    event MinterAdded(address indexed account);
    event MinterRemoved(address indexed account);

    Roles.Role private _minters;

    constructor () internal {
        _addMinter(_msgSender());
    }

    modifier onlyMinter() {
        require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
        _;
    }

    function isMinter(address account) public view returns (bool) {
        return _minters.has(account);
    }

    function addMinter(address account) public onlyMinter {
        _addMinter(account);
    }

    function renounceMinter() public {
        _removeMinter(_msgSender());
    }

    function _addMinter(address account) internal {
        _minters.add(account);
        emit MinterAdded(account);
    }

    function _removeMinter(address account) internal {
        _minters.remove(account);
        emit MinterRemoved(account);
    }
}

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

pragma solidity ^0.5.0;



/**
 * @dev Extension of {ERC20} that adds a set of accounts with the {MinterRole},
 * which have permission to mint (create) new tokens as they see fit.
 *
 * At construction, the deployer of the contract is the only minter.
 */
contract ERC20Mintable is ERC20, MinterRole {
    /**
     * @dev See {ERC20-_mint}.
     *
     * Requirements:
     *
     * - the caller must have the {MinterRole}.
     */
    function mint(address account, uint256 amount) public onlyMinter returns (bool) {
        _mint(account, amount);
        return true;
    }
}

// File: contracts/external/FsToken.sol

pragma solidity ^0.5.17;




// The 'code' of FS token.
// The token is non transferable.
// Note: that any changes to layout of storage have to work with the proxy.
// To be safe here one should only be adding to storage and needs to make sure
// that none of the base classes change their storage layout.
contract FsToken is ERC20Snapshot, ERC20Mintable, ERC20Burnable {
    constructor() public {}

    function transferFrom(
        address, /*sender*/
        address, /*recipient*/
        uint256 /*amount*/
    ) public returns (bool) {
        revert("FST are not transferable");
    }

    function transfer(
        address, /*recipient*/
        uint256 /*amount*/
    ) public returns (bool) {
        revert("FST are not transferable");
    }

    function name() public pure returns (string memory) {
        return "Futureswap";
    }

    function symbol() public pure returns (string memory) {
        return "FST";
    }

    function decimals() public pure returns (uint8) {
        return 18;
    }
}

// File: contracts/registry/IRegistry.sol

pragma solidity ^0.5.17;

contract IRegistry {
    function getVotingAddress() public view returns (address);

    function getExchangeFactoryAddress() public view returns (address);

    function getWethAddress() public view returns (address);

    function getMessageProcessorAddress() public view returns (address);

    function getFsTokenAddress() public view returns (address);

    function getFsTokenProxyAdminAddress() public view returns (address);

    function getIncentivesAddress() public view returns (address);

    function getWalletAddress() public view returns (address payable);

    function getReplayTrackerAddress() public view returns (address);

    function getLiquidityTokenFactoryAddress() public view returns (address);

    function hasLiquidityTokensnapshotAccess(address sender) public view returns (bool);

    function hasWalletAccess(address sender) public view returns (bool);

    function removeWalletAccess(address _walletAccessor) public;

    function isValidOracleAddress(address oracleAddress) public view returns (bool);

    function isValidVerifierAddress(address verifierAddress) public view returns (bool);

    function isValidStamperAddress(address stamperAddress) public view returns (bool);

    function isExchange(address exchangeAddress) public view returns (bool);

    function addExchange(address _exchange) public;

    function removeExchange(address _exchange) public;

    function updateVotingAddress(address _address) public;
}

// File: contracts/registry/IRegistryUpdateConsumer.sol

pragma solidity ^0.5.17;

// Implemented by objects that need to know about registry updates.
interface IRegistryUpdateConsumer {
    function onRegistryRefresh() external;
}

// File: contracts/registry/RegistryHolder.sol

pragma solidity ^0.5.17;



// Holds a reference to the registry
// Eventually Ownership will be renounced
contract RegistryHolder is Ownable {
    address private registryAddress;

    function getRegistryAddress() public view returns (address) {
        return registryAddress;
    }

    // Change the address of registry, if the caller is the voting system as identified by the old
    // registry.
    function updateRegistry(address _newAddress) public {
        require(isOwner() || isVotingSystem(), "Only owner or voting system");
        require(_newAddress != address(0), "Zero address");
        registryAddress = _newAddress;
    }

    function isVotingSystem() private view returns (bool) {
        if (registryAddress == address(0)) {
            return false;
        }
        return IRegistry(registryAddress).getVotingAddress() == msg.sender;
    }
}

// File: contracts/registry/KnowsRegistry.sol

pragma solidity ^0.5.17;




// Base class for objects that need to know about other objects in the system
// This allows us to share modifiers and have a unified way of looking up other objects.
contract KnowsRegistry is IRegistryUpdateConsumer {
    RegistryHolder private registryHolder;

    modifier onlyVotingSystem() {
        require(isVotingSystem(msg.sender), "Only voting system");
        _;
    }

    modifier onlyExchangeFactory() {
        require(isExchangeFactory(msg.sender), "Only exchange factory");
        _;
    }

    modifier onlyExchangeFactoryOrVotingSystem() {
        require(isExchangeFactory(msg.sender) || isVotingSystem(msg.sender), "Only exchange factory or voting");
        _;
    }

    modifier requiresWalletAcccess() {
        require(getRegistry().hasWalletAccess(msg.sender), "requires wallet access");
        _;
    }

    modifier onlyMessageProcessor() {
        require(getRegistry().getMessageProcessorAddress() == msg.sender, "only MessageProcessor");
        _;
    }

    modifier onlyExchange() {
        require(getRegistry().isExchange(msg.sender), "Only exchange");
        _;
    }

    modifier onlyRegistry() {
        require(getRegistryAddress() == msg.sender, "only registry");
        _;
    }

    modifier onlyOracle() {
        require(isValidOracleAddress(msg.sender), "only oracle");
        _;
    }

    modifier requiresLiquidityTokenSnapshotAccess() {
        require(getRegistry().hasLiquidityTokensnapshotAccess(msg.sender), "only incentives");
        _;
    }

    constructor(address _registryHolder) public {
        registryHolder = RegistryHolder(_registryHolder);
    }

    function getRegistryHolder() internal view returns (RegistryHolder) {
        return registryHolder;
    }

    function getRegistry() internal view returns (IRegistry) {
        return IRegistry(getRegistryAddress());
    }

    function getRegistryAddress() internal view returns (address) {
        return registryHolder.getRegistryAddress();
    }

    function isRegistryHolder(address a) internal view returns (bool) {
        return a == address(registryHolder);
    }

    function isValidOracleAddress(address oracleAddress) public view returns (bool) {
        return getRegistry().isValidOracleAddress(oracleAddress);
    }

    function isValidVerifierAddress(address verifierAddress) public view returns (bool) {
        return getRegistry().isValidVerifierAddress(verifierAddress);
    }

    function isValidStamperAddress(address stamperAddress) public view returns (bool) {
        return getRegistry().isValidStamperAddress(stamperAddress);
    }

    function isVotingSystem(address a) public view returns (bool) {
        return a == getRegistry().getVotingAddress();
    }

    function isExchangeFactory(address a) public view returns (bool) {
        return a == getRegistry().getExchangeFactoryAddress();
    }

    function checkNotNull(address a) internal pure returns (address) {
        require(a != address(0), "address must be non zero");
        return a;
    }

    function checkNotNullAP(address payable a) internal pure returns (address payable) {
        require(a != address(0), "address must be non zero");
        return a;
    }
}

// File: contracts/voting/Voting.sol

pragma solidity ^0.5.17;






contract Voting is KnowsRegistry, Ownable, ReentrancyGuard {
    using SafeMath for uint256;

    uint256 public constant proposalFstStake = 100 ether;
    uint256 public constant minimumVoteTime = 2 days;
    uint256 public proposalCount;
    uint256 public pauseTimestamp;

    event ProposalCreated(uint256 indexed proposalId, string action, string title, string description);
    event VotedCasted(address indexed voter, uint256 indexed proposalId, uint256 amountOfVotes, bool isYesVote);
    event ProposalAccepted(uint256 indexed proposalId);
    event ProposalRejected(uint256 indexed proposalId);
    event ProposalCallFailed(uint256 indexed proposalId);

    struct Proposal {
        uint256 id;
        uint256 votingEnds; // epoch time in seconds when a vote will be able to be resolved and further votes will be rejected
        address to; // The address to which the result of the vote will be sent to
        bool isVoteResolved;
        bool isUpgradeProposal; // bool if the true the proposal is an upgrade proposal that goes to this specific address and assumes the data is a 20 byte address, if false it is a regular vote
        uint256 yesVotes; // amount of yes votes
        uint256 noVotes; // amount of no votes
        uint256 fstSnapshotId; // snapshot of tokens when the proposal was started
        address proposer; // the address of the creator of the vote
        mapping(address => bool) didVote; // tracks which addresses have voted
        bytes data; // byte data to use in a call (regular vote abi encoded data) - upgrade vote 20 bytes address
        bool ownerApproved; // is initially used by the owner to force votes to succeed without a full vote. Ownership will be phased out
    }

    mapping(uint256 => Proposal) public proposals;

    constructor(address _registryHolder) public KnowsRegistry(_registryHolder) {}

    function createProposal(
        address _to,
        bytes memory _data,
        string memory _action,
        string memory _title,
        string memory _description
    ) public {
        require(pauseTimestamp == 0, "proposals are paused");

        // We make users stake FST for creating a proposal to avoid
        // spammers creating proposals.
        // Funds are only returned on a successful proposal.
        FsToken fsToken = getFsToken();
        fsToken.burnFrom(msg.sender, proposalFstStake);

        bool isUpgradeProposal = _to == address(this);
        if (isUpgradeProposal) {
            // If this is an upgrade propsal the update address is saved
            // in the data field. We ensure here that the bytes field
            // has the length of a address (20 bytes).
            require(_data.length == 20, "data needs to be 20 bytes long");
        }

        Proposal storage p = proposals[proposalCount];
        p.id = proposalCount;
        p.votingEnds = now.add(minimumVoteTime);
        p.data = _data;
        p.to = _to;
        p.fstSnapshotId = fsToken.snapshot();
        p.proposer = msg.sender;
        p.isUpgradeProposal = isUpgradeProposal;

        emit ProposalCreated(proposalCount, _action, _title, _description);
        proposalCount++;
    }

    function vote(uint256 _proposalId, bool _isYesVote) public {
        requireProposalExists(_proposalId);
        Proposal storage p = proposals[_proposalId];
        require(now <= p.votingEnds, "vote is not open");
        require(!p.didVote[msg.sender], "already voted");

        p.didVote[msg.sender] = true;

        uint256 amountOfVotes = getFsToken().balanceOfAt(msg.sender, p.fstSnapshotId);

        if (_isYesVote) {
            p.yesVotes = p.yesVotes.add(amountOfVotes);
        } else {
            p.noVotes = p.noVotes.add(amountOfVotes);
        }
        emit VotedCasted(msg.sender, _proposalId, amountOfVotes, _isYesVote);
    }

    function pause(uint256 _proposalId) public {
        requireProposalExists(_proposalId);
        Proposal storage p = proposals[_proposalId];
        requireProposalCanBeResolved(p);
        require(p.isUpgradeProposal);

        require(pauseTimestamp == 0, "system already paused");
        pauseTimestamp = now;
    }

    function resolve(uint256 _proposalId) public nonReentrant {
        // Gas estimation is broken in ethereum for contract
        // factories. This has been reported a long time ago but never
        // got resolved:
        // https://github.com/ethereum/go-ethereum/issues/1590
        //
        // Requiring a high gas amount to start here makes this work for now
        // Note: this does not mean that all the gas will actually be used.
        // If the particular vote requires less gas users will be refunded.
        require(gasleft() >= 8000000, "Please use 8M+ gas to resolve");

        requireProposalExists(_proposalId);
        Proposal storage p = proposals[_proposalId];
        requireProposalCanBeResolved(p);

        if (p.isUpgradeProposal && !p.ownerApproved) {
            require(pauseTimestamp != 0, "pause first");
            require(now >= pauseTimestamp.add(minimumVoteTime), "pauseVotes");
        }

        p.isVoteResolved = true;

        bool votePassed = p.yesVotes > p.noVotes || p.ownerApproved;

        if (!votePassed) {
            emit ProposalRejected(_proposalId);
            return;
        }

        bool successful = p.isUpgradeProposal ? upgradeVoteExecution(p) : regularVoteExecution(p);
        if (!successful) {
            emit ProposalCallFailed(_proposalId);
            return;
        }

        emit ProposalAccepted(_proposalId);
    }

    function regularVoteExecution(Proposal storage p) private returns (bool) {
        (bool success, ) = p.to.call(p.data);
        if (success) {
            // Only mint initial tokens back if the vote passed
            FsToken fsToken = getFsToken();
            fsToken.mint(p.proposer, proposalFstStake);
        }
        return success;
    }

    function upgradeVoteExecution(Proposal storage p) private returns (bool) {
        address newAddress = bytesToAddress(p.data);
        // We update all other contracts with the new address
        // If any of these calls should fail we let the entire transaction fail.
        // This would allow anybody to call resolve again and retry since the
        // vote would have not gotten marked as resolved.
        // However if any of the steps here fail the system is in a problematic state.
        // All of these contracts have been written by us and should not fail.
        getFsToken().mint(p.proposer, proposalFstStake);
        doUpgrade(newAddress);

        return true;
    }

    function didAddressVote(uint256 _proposalId, address _voter) public view returns (bool) {
        return proposals[_proposalId].didVote[_voter];
    }

    // Allows owners to approve a vote, ownership will be phased out.
    function approve(uint256 _proposalId) public onlyOwner {
        proposals[_proposalId].ownerApproved = true;
    }

    // Allows owners to veto a vote, ownership will be phased out.
    function veto(uint256 _proposalId) public onlyOwner {
        proposals[_proposalId].isVoteResolved = true;
    }

    // Allows owners to upgrade the contract without a vote, ownership will be phased out.
    function ownableUpgrade(address _newAddress) public onlyOwner {
        doUpgrade(_newAddress);
    }

    function doUpgrade(address newAddress) private {
        Ownable(getRegistry().getFsTokenProxyAdminAddress()).transferOwnership(newAddress);
        FsToken fsToken = getFsToken();
        fsToken.addMinter(newAddress);
        fsToken.renounceMinter();
        getRegistry().updateVotingAddress(newAddress);
    }

    function requireProposalExists(uint256 proposalId) private view {
        require(proposalId < proposalCount, "Nonexisting proposal");
    }

    function requireProposalCanBeResolved(Proposal memory p) private view {
        require(now > p.votingEnds || p.ownerApproved, "vote is still open");
        require(!p.isVoteResolved, "already resolved");

        FsToken fsToken = getFsToken();
        uint256 totalFstSupply = fsToken.totalSupplyAt(p.fstSnapshotId);
        uint256 totalVotes = p.yesVotes.add(p.noVotes);
        bool aboveThreshold = (totalFstSupply / 10) <= totalVotes;
        require(aboveThreshold || p.ownerApproved, "The voting threshold has not been met");
    }

    function bytesToAddress(bytes memory bys) private pure returns (address addr) {
        require(bys.length == 20, "data needs to be 20 bytes long");
        // A quick way to load 2 bytes into the address variable
        assembly {
            addr := mload(add(bys, 20))
        }
    }

    function getFsToken() private view returns (FsToken) {
        return FsToken(getRegistry().getFsTokenAddress());
    }

    function onRegistryRefresh() public onlyRegistry {
        // No op since we always read all address directly from the registryHolder pointer
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_registryHolder","type":"address"}],"payable":false,"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":"uint256","name":"proposalId","type":"uint256"}],"name":"ProposalAccepted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"proposalId","type":"uint256"}],"name":"ProposalCallFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"proposalId","type":"uint256"},{"indexed":false,"internalType":"string","name":"action","type":"string"},{"indexed":false,"internalType":"string","name":"title","type":"string"},{"indexed":false,"internalType":"string","name":"description","type":"string"}],"name":"ProposalCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"proposalId","type":"uint256"}],"name":"ProposalRejected","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"voter","type":"address"},{"indexed":true,"internalType":"uint256","name":"proposalId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOfVotes","type":"uint256"},{"indexed":false,"internalType":"bool","name":"isYesVote","type":"bool"}],"name":"VotedCasted","type":"event"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_proposalId","type":"uint256"}],"name":"approve","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"},{"internalType":"string","name":"_action","type":"string"},{"internalType":"string","name":"_title","type":"string"},{"internalType":"string","name":"_description","type":"string"}],"name":"createProposal","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"_proposalId","type":"uint256"},{"internalType":"address","name":"_voter","type":"address"}],"name":"didAddressVote","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"a","type":"address"}],"name":"isExchangeFactory","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"oracleAddress","type":"address"}],"name":"isValidOracleAddress","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"stamperAddress","type":"address"}],"name":"isValidStamperAddress","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"verifierAddress","type":"address"}],"name":"isValidVerifierAddress","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"a","type":"address"}],"name":"isVotingSystem","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"minimumVoteTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"onRegistryRefresh","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_newAddress","type":"address"}],"name":"ownableUpgrade","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_proposalId","type":"uint256"}],"name":"pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"pauseTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"proposalCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"proposalFstStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"proposals","outputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"votingEnds","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bool","name":"isVoteResolved","type":"bool"},{"internalType":"bool","name":"isUpgradeProposal","type":"bool"},{"internalType":"uint256","name":"yesVotes","type":"uint256"},{"internalType":"uint256","name":"noVotes","type":"uint256"},{"internalType":"uint256","name":"fstSnapshotId","type":"uint256"},{"internalType":"address","name":"proposer","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bool","name":"ownerApproved","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_proposalId","type":"uint256"}],"name":"resolve","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_proposalId","type":"uint256"}],"name":"veto","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_proposalId","type":"uint256"},{"internalType":"bool","name":"_isYesVote","type":"bool"}],"name":"vote","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000d9cf4ca71d2ed15040cc702c2b146bfb848b7a1b

-----Decoded View---------------
Arg [0] : _registryHolder (address): 0xd9cF4cA71D2Ed15040cC702c2B146Bfb848b7A1B

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000d9cf4ca71d2ed15040cc702c2b146bfb848b7a1b

43611:9132:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43611:9132:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45371:45;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45371:45:0;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;45371:45:0;-1:-1:-1;;;;;45371:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;45371:45:0;-1:-1:-1;;;;;45371:45: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;45371:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47523:328;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47523:328:0;;:::i;:::-;;52591:149;;;:::i;50798:115::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50798:115:0;;:::i;45510:1333::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;45510:1333:0;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;45510:1333:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;45510:1333:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;45510:1333:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;45510:1333:0;;;;;;;;-1:-1:-1;45510:1333:0;;-1:-1:-1;;;;;5:28;;2:2;;;46:1;43;36:12;2:2;45510:1333:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;45510:1333:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;45510:1333:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;45510:1333:0;;;;;;;;-1:-1:-1;45510:1333:0;;-1:-1:-1;;;;;5:28;;2:2;;;46:1;43;36:12;2:2;45510:1333:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;45510:1333:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;45510:1333:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;45510:1333:0;;;;;;;;-1:-1:-1;45510:1333:0;;-1:-1:-1;;;;;5:28;;2:2;;;46:1;43;36:12;2:2;45510:1333:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;45510:1333:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;45510:1333:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;45510:1333:0;;-1:-1:-1;45510:1333:0;;-1:-1:-1;;;;;45510:1333:0:i;42411:155::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42411:155:0;-1:-1:-1;;;;;42411:155:0;;:::i;:::-;;;;;;;;;;;;;;;;;;42574:163;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42574:163:0;-1:-1:-1;;;;;42574:163:0;;:::i;47859:1436::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47859:1436:0;;:::i;8473:140::-;;;:::i;43045:137::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;43045:137:0;-1:-1:-1;;;;;43045:137:0;;:::i;7662:79::-;;;:::i;:::-;;;;-1:-1:-1;;;;;7662:79:0;;;;;;;;;;;;;;8028:94;;;:::i;51013:103::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51013:103:0;-1:-1:-1;;;;;51013:103:0;;:::i;42912:125::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42912:125:0;-1:-1:-1;;;;;42912:125:0;;:::i;43861:29::-;;;:::i;:::-;;;;;;;;;;;;;;;;50605:117;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50605:117:0;;:::i;42745:159::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42745:159:0;-1:-1:-1;;;;;42745:159:0;;:::i;46851:664::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46851:664:0;;;;;;;;;:::i;43826:28::-;;;:::i;50374:152::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50374:152:0;;;;;;-1:-1:-1;;;;;50374:152:0;;:::i;43712:52::-;;;:::i;8768:109::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;8768:109:0;-1:-1:-1;;;;;8768:109:0;;:::i;43771:48::-;;;:::i;45371:45::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;45371:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;45371:45:0;;;;-1:-1:-1;;;45371:45:0;;;;;;;-1:-1:-1;;;45371:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;45371:45:0;;;;;;;-1:-1:-1;;45371:45:0;;;:::o;47523:328::-;47577:34;47599:11;47577:21;:34::i;:::-;47622:18;47643:22;;;:9;:22;;;;;;;;;47676:31;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;47676:31:0;;;;;;;-1:-1:-1;;;47676:31:0;;;;;;;;;;;;-1:-1:-1;;;47676:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;47676:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;47643:22;;47676:31;;;;47643:22;;47676:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;47676:31:0;;;-1:-1:-1;;47676:31:0;;;;;;;;;;;;;;;:28;:31::i;:::-;47726:19;;;;-1:-1:-1;;;47726:19:0;;;;47718:28;;;;;;47767:14;;:19;47759:53;;;;;-1:-1:-1;;;47759:53:0;;;;;;;;;;;;-1:-1:-1;;;47759:53:0;;;;;;;;;;;;;;;-1:-1:-1;;47840:3:0;47823:14;:20;47523:328::o;52591:149::-;41450:10;41426:20;:18;:20::i;:::-;-1:-1:-1;;;;;41426:34:0;;41418:60;;;;;-1:-1:-1;;;41418:60:0;;;;;;;;;;;;-1:-1:-1;;;41418:60:0;;;;;;;;;;;;;;;52591:149::o;50798:115::-;7874:9;:7;:9::i;:::-;7866:54;;;;;-1:-1:-1;;;7866:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7866:54:0;;;;;;;;;;;;;;;50861:22;;;;:9;:22;;;;;:37;;:44;;-1:-1:-1;;;;50861:44:0;-1:-1:-1;;;50861:44:0;;;50798:115::o;45510:1333::-;45718:14;;:19;45710:52;;;;;-1:-1:-1;;;45710:52:0;;;;;;;;;;;;-1:-1:-1;;;45710:52:0;;;;;;;;;;;;;;;45947:15;45965:12;:10;:12::i;:::-;45988:46;;;-1:-1:-1;;;45988:46:0;;46005:10;45988:46;;;;43755:9;45988:46;;;;;;45947:30;;-1:-1:-1;;;;;;45988:16:0;;;;;:46;;;;;-1:-1:-1;;45988:46:0;;;;;;;;-1:-1:-1;45988:16:0;:46;;;5:2:-1;;;;30:1;27;20:12;5:2;45988:46:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;;;;;;;;46072:20:0;;46087:4;46072:20;46103:312;;;;46350:5;:12;46366:2;46350:18;46342:61;;;;;-1:-1:-1;;;46342:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;46458:13;;46427:18;46448:24;;;:9;:24;;;;;46483:20;;;46529:24;:3;43813:6;46529:24;:7;:24;:::i;:::-;46514:12;;;:39;46564:14;;;;:6;;;;:14;;;;;:::i;:::-;;46596:3;46589:1;:4;;;:10;;;;;-1:-1:-1;;;;;46589:10:0;;;;;-1:-1:-1;;;;;46589:10:0;;;;;;46628:7;-1:-1:-1;;;;;46628:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;46628:18:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;46628:18:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46628:18:0;46610:15;;;:36;46657:10;;;:23;;-1:-1:-1;;;;;;46657:23:0;46670:10;46657:23;;;46691:19;;;;:39;;;;;-1:-1:-1;;;46691:39:0;-1:-1:-1;;;;46691:39:0;;;;;;46764:13;46748:61;;;;;;;;;;;;;;;;;46779:7;;46788:6;;46796:12;;46748:61;;46628:18;46748:61;;;;;;;;;;;;;;;;;46657:10;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;46748:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46748:61: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;46748:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46748:61: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;46748:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;46820:13:0;:15;;;;;;-1:-1:-1;;;;;;45510:1333:0:o;42411:155::-;42485:4;42509:13;:11;:13::i;:::-;-1:-1:-1;;;;;42509:34:0;;42544:13;42509:49;;;;;;;;;;;;;-1:-1:-1;;;;;42509:49:0;-1:-1:-1;;;;;42509:49:0;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42509:49:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;42509:49:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42509:49:0;;42411:155;-1:-1:-1;;42411:155:0:o;42574:163::-;42652:4;42676:13;:11;:13::i;:::-;-1:-1:-1;;;;;42676:36:0;;42713:15;42676:53;;;;;;;;;;;;;-1:-1:-1;;;;;42676:53:0;-1:-1:-1;;;;;42676:53:0;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;47859:1436:0;11258:11;;-1:-1:-1;;;11258:11:0;;;;11250:55;;;;;-1:-1:-1;;;11250:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;11383:11;:19;;-1:-1:-1;;;;11383:19:0;;;48417:7;48404:9;:20;;48396:62;;;;;-1:-1:-1;;;48396:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;48471:34;48493:11;48471:21;:34::i;:::-;48516:18;48537:22;;;:9;:22;;;;;;;;;48570:31;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48570:31:0;;;;;;;-1:-1:-1;;;48570:31:0;;;;;;;;;;;;-1:-1:-1;;;48570:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;48570:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;48537:22;;48570:31;;;;48537:22;;48570:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48618:19;;;;-1:-1:-1;;;48618:19:0;;;;:39;;;;-1:-1:-1;48642:15:0;;;;;;48641:16;48618:39;48614:195;;;48682:14;;48674:43;;;;;-1:-1:-1;;;48674:43:0;;;;;;;;;;;;-1:-1:-1;;;48674:43:0;;;;;;;;;;;;;;;48747:14;;:35;;43813:6;48747:35;:18;:35;:::i;:::-;48740:3;:42;;48732:65;;;;;-1:-1:-1;;;48732:65:0;;;;;;;;;;;;-1:-1:-1;;;48732:65:0;;;;;;;;;;;;;;;48821:16;;;:23;;-1:-1:-1;;;;48821:23:0;-1:-1:-1;;;48821:23:0;;;48888:9;;;;48875:10;;;;48821:23;;-1:-1:-1;48875:22:0;:41;;-1:-1:-1;48901:15:0;;;;;;48875:41;48857:59;;48934:10;48929:99;;48966:29;;48983:11;;48966:29;;;;;49010:7;;;;48929:99;49058:19;;;;49040:15;;-1:-1:-1;;;49058:19:0;;;;:71;;49106:23;49127:1;49106:20;:23::i;:::-;49058:71;;;49080:23;49101:1;49080:20;:23::i;:::-;49040:89;;49145:10;49140:101;;49177:31;;49196:11;;49177:31;;;;;49223:7;;;;;49140:101;49258:29;;49275:11;;49258:29;;;;;11415:1;;;;-1:-1:-1;11577:4:0;11563:18;;-1:-1:-1;;;;11563:18:0;-1:-1:-1;;;11563:18:0;;;47859:1436::o;8473:140::-;7874:9;:7;:9::i;:::-;7866:54;;;;;-1:-1:-1;;;7866:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7866:54:0;;;;;;;;;;;;;;;8556:6;;8535:40;;8572:1;;-1:-1:-1;;;;;8556:6:0;;8535:40;;8572:1;;8535:40;8586:6;:19;;-1:-1:-1;;;;;;8586:19:0;;;8473:140::o;43045:137::-;43104:4;43133:13;:11;:13::i;:::-;-1:-1:-1;;;;;43133:39:0;;:41;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43133:41:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;43133:41:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;43133:41:0;-1:-1:-1;;;;;43128:46:0;;;;;;;-1:-1:-1;43045:137:0;;;:::o;7662:79::-;7727:6;;-1:-1:-1;;;;;7727:6:0;7662:79;;:::o;8028:94::-;8108:6;;8068:4;;-1:-1:-1;;;;;8108:6:0;8092:12;:10;:12::i;:::-;-1:-1:-1;;;;;8092:22:0;;8085:29;;8028:94;:::o;51013:103::-;7874:9;:7;:9::i;:::-;7866:54;;;;;-1:-1:-1;;;7866:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7866:54:0;;;;;;;;;;;;;;;51086:22;51096:11;51086:9;:22::i;:::-;51013:103;:::o;42912:125::-;42968:4;42997:13;:11;:13::i;:::-;-1:-1:-1;;;;;42997:30:0;;:32;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;43861:29:0;;;;:::o;50605:117::-;7874:9;:7;:9::i;:::-;7866:54;;;;;-1:-1:-1;;;7866:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7866:54:0;;;;;;;;;;;;;;;50671:22;;;;:9;:22;;;;;:36;;:43;;-1:-1:-1;;50671:43:0;50710:4;50671:43;;;50605:117::o;42745:159::-;42821:4;42845:13;:11;:13::i;:::-;-1:-1:-1;;;;;42845:35:0;;42881:14;42845:51;;;;;;;;;;;;;-1:-1:-1;;;;;42845:51:0;-1:-1:-1;;;;;42845:51:0;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;46851:664:0;46921:34;46943:11;46921:21;:34::i;:::-;46966:18;46987:22;;;:9;:22;;;;;47035:12;;;;47028:3;:19;;47020:48;;;;;-1:-1:-1;;;47020:48:0;;;;;;;;;;;;-1:-1:-1;;;47020:48:0;;;;;;;;;;;;;;;47098:10;47088:21;;;;:9;;;:21;;;;;;;;47087:22;47079:48;;;;;-1:-1:-1;;;47079:48:0;;;;;;;;;;;;-1:-1:-1;;;47079:48:0;;;;;;;;;;;;;;;47150:10;47140:21;;;;:9;;;:21;;;;;:28;;-1:-1:-1;;47140:28:0;47164:4;47140:28;;;47205:12;:10;:12::i;:::-;-1:-1:-1;;;;;47205:24:0;;47230:10;47242:1;:15;;;47205:53;;;;;;;;;;;;;-1:-1:-1;;;;;47205:53:0;-1:-1:-1;;;;;47205:53:0;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47205:53:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47205:53:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47205:53:0;;-1:-1:-1;47271:158:0;;;;47315:10;;;;:29;;47330:13;47315:29;:14;:29;:::i;:::-;47302:10;;;:42;47271:158;;;47389:9;;;;:28;;47403:13;47389:28;:13;:28;:::i;:::-;47377:9;;;:40;47271:158;47444:63;;;;;;;;;;;;;;;47468:11;;47456:10;;47444:63;;;;;;;;;;;46851:664;;;;:::o;43826:28::-;;;;:::o;50374:152::-;50456:4;50480:22;;;:9;:22;;;;;;;;-1:-1:-1;;;;;50480:38:0;;;;:30;;:38;;;;;;;;50374:152;;;;:::o;43712:52::-;43755:9;43712:52;:::o;8768:109::-;7874:9;:7;:9::i;:::-;7866:54;;;;;-1:-1:-1;;;7866:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7866:54:0;;;;;;;;;;;;;;;8841:28;8860:8;8841:18;:28::i;43771:48::-;43813:6;43771:48;:::o;51452:142::-;51548:13;;51535:10;:26;51527:59;;;;;-1:-1:-1;;;51527:59:0;;;;;;;;;;;;-1:-1:-1;;;51527:59:0;;;;;;;;;;;;;;51602:550;51697:1;:12;;;51691:3;:18;:37;;;;51713:1;:15;;;51691:37;51683:68;;;;;-1:-1:-1;;;51683:68:0;;;;;;;;;;;;-1:-1:-1;;;51683:68:0;;;;;;;;;;;;;;;51771:1;:16;;;51770:17;51762:46;;;;;-1:-1:-1;;;51762:46:0;;;;;;;;;;;;-1:-1:-1;;;51762:46:0;;;;;;;;;;;;;;;51821:15;51839:12;:10;:12::i;:::-;51821:30;;51862:22;51887:7;-1:-1:-1;;;;;51887:21:0;;51909:1;:15;;;51887:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51887:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51887:38:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51887:38:0;51972:9;;;;51957:10;;;;51887:38;;-1:-1:-1;51936:18:0;;51957:25;;;:14;:25;:::i;:::-;51936:46;-1:-1:-1;52033:2:0;52016:19;;52015:35;-1:-1:-1;52015:35:0;;;52069:33;;;52087:1;:15;;;52069:33;52061:83;;;;-1:-1:-1;;;52061:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51602:550;;;;;:::o;42152:123::-;42205:7;42232:14;;;;;;;;;-1:-1:-1;;;;;42232:14:0;-1:-1:-1;;;;;42232:33:0;;:35;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42232:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;42232:35:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42232:35:0;;-1:-1:-1;42152:123:0;:::o;52462:121::-;52506:7;52541:13;:11;:13::i;:::-;-1:-1:-1;;;;;52541:31:0;;:33;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;913:181:0;971:7;1003:5;;;1027:6;;;;1019:46;;;;;-1:-1:-1;;;1019:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1085:1;913:181;-1:-1:-1;;;913:181:0:o;42030:114::-;42076:9;42115:20;:18;:20::i;:::-;42098:38;;42030:114;:::o;49303:355::-;49406:4;;;;;:17;;49416:6;;;49406:17;;49370:4;;;;-1:-1:-1;;;;;49406:4:0;;:17;;;49416:6;;-1:-1:-1;;49406:4:0;:17;;;:4;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;49387:36:0;;;49438:7;49434:192;;;49527:15;49545:12;:10;:12::i;:::-;49585:10;;;;49572:42;;;-1:-1:-1;;;49572:42:0;;-1:-1:-1;;;;;49585:10:0;;;49572:42;;;;43755:9;49572:42;;;;;;49527:30;;-1:-1:-1;49572:12:0;;;;;;:42;;;;;;;;;;;;;;;49585:10;49572:12;:42;;;5:2:-1;;;;30:1;27;20:12;5:2;49572:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49572:42:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;49434:192:0;49643:7;49303:355;-1:-1:-1;;49303:355:0:o;49666:700::-;49786:6;;;49771:22;;;;;;;;-1:-1:-1;;49771:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49733:4;;;;49771:22;;;;49786:6;49771:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:14;:22::i;:::-;49750:43;;50255:12;:10;:12::i;:::-;50273:10;;;;50255:47;;;-1:-1:-1;;;50255:47:0;;-1:-1:-1;;;;;50273:10:0;;;50255:47;;;;43755:9;50255:47;;;;;;:17;;;;;;;:47;;;;;;;;;;;;;;;50273:10;50255:17;:47;;;5:2:-1;;;;30:1;27;20:12;5:2;50255:47:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50255:47:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50313:21:0;;-1:-1:-1;50323:10:0;50313:9;:21::i;:::-;-1:-1:-1;50354:4:0;;49666:700;-1:-1:-1;;49666:700:0:o;6368:98::-;6448:10;6368:98;:::o;51124:320::-;51190:13;:11;:13::i;:::-;-1:-1:-1;;;;;51190:41:0;;:43;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51190:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51190:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51190:43:0;51182:82;;;-1:-1:-1;;;51182:82:0;;-1:-1:-1;;;;;51182:82:0;;;;;;;;;:70;;;;;;;:82;;;;;-1:-1:-1;;51182:82:0;;;;;;;-1:-1:-1;51182:70:0;:82;;;5:2:-1;;;;30:1;27;20:12;5:2;51182:82:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51182:82:0;;;;51275:15;51293:12;:10;:12::i;:::-;51275:30;;51316:7;-1:-1:-1;;;;;51316:17:0;;51334:10;51316:29;;;;;;;;;;;;;-1:-1:-1;;;;;51316:29:0;-1:-1:-1;;;;;51316:29:0;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51316:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51316:29:0;;;;51356:7;-1:-1:-1;;;;;51356:22:0;;:24;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51356:24:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51356:24:0;;;;51391:13;:11;:13::i;:::-;-1:-1:-1;;;;;51391:33:0;;51425:10;51391:45;;;;;;;;;;;;;-1:-1:-1;;;;;51391:45:0;-1:-1:-1;;;;;51391:45:0;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51391:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51391:45:0;;;;51124:320;;:::o;8983:229::-;-1:-1:-1;;;;;9057:22:0;;9049:73;;;;-1:-1:-1;;;9049:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9159:6;;9138:38;;-1:-1:-1;;;;;9138:38:0;;;;9159:6;;9138:38;;9159:6;;9138:38;9187:6;:17;;-1:-1:-1;;;;;;9187:17:0;-1:-1:-1;;;;;9187:17:0;;;;;;;;;;8983:229::o;52160:294::-;52224:12;52257:3;:10;52271:2;52257:16;52249:59;;;;;-1:-1:-1;;;52249:59:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52432:2:0;52423:12;52417:19;;52394:53::o;43611:9132::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43611:9132:0;;;-1:-1:-1;43611:9132:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;

bzzr://21000abbba9b436ddfb34ac825f3c493c11f5f00d4daf06ee7d518d07af822b3