Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library Require
•    - function that(
•    - function that(
•    - function that(
•    - function that(
•    - function that(
•    - function that(
•    - function that(
•    - function that(
•    - function stringifyTruncated(
•    - function stringify(
•    - function stringify(
•    - function stringify(
•    - function char(
• library Decimal
•    - function zero()
•    - function one()
•    - function from(
•    - function ratio(
•    - function add(
•    - function sub(
•    - function sub(
•    - function mul(
•    - function div(
•    - function pow(
•    - function add(
•    - function sub(
•    - function sub(
•    - function mul(
•    - function div(
•    - function equals(D256 memory self, D25 ...
•    - function greaterThan(D256 memory self ...
•    - function lessThan(D256 memory self, D ...
•    - function greaterThanOrEqualTo(D256 me ...
•    - function lessThanOrEqualTo(D256 memor ...
•    - function isZero(D256 memory self)
•    - function asUint256(D256 memory self)
•    - function getPartial(
•    - function compareTo(
• library Constants
•    - function getSXAUAddress()
•    - function getOracleReserveMinimum()
•    - function getCurrentEpochStrategy()
•    - function getInitialStakeMultiple()
•    - function getBootstrappingPeriod()
•    - function getBootstrappingPrice()
•    - function getGovernancePeriod()
•    - function getGovernanceExpiration()
•    - function getGovernanceQuorum()
•    - function getGovernanceProposalThresho ...
•    - function getGovernanceSuperMajority()
•    - function getGovernanceEmergencyDelay( ...
•    - function getAdvanceIncentive()
•    - function getDAOExitLockupEpochs()
•    - function getPoolExitLockupEpochs()
•    - function getCouponExpiration()
•    - function getDebtRatioCap()
•    - function getSupplyChangeLimit()
•    - function getCouponSupplyChangeLimit()
•    - function getOraclePoolRatio()
•    - function getTreasuryRatio()
•    - function getChainId()
•    - function getTreasuryAddress()
•  contract IGold is IERC20
•    - function burn(uint256 amount)
•    - function burnFrom(address account, ui ...
•    - function mint(address account, uint25 ...
•  contract IDAO
•    - function epoch()
•  contract PoolAccount *
•  contract PoolStorage *
•  contract PoolState *
•  contract PoolGetters is PoolState *
•    - function sXAU()
•    - function dao()
•    - function gold()
•    - function univ2()
•    - function totalBonded()
•    - function totalStaged()
•    - function totalClaimable()
•    - function totalPhantom()
•    - function totalRewarded(IGold gold)
•    - function paused()
•    - function balanceOfStaged(address acco ...
•    - function balanceOfClaimable(address a ...
•    - function balanceOfBonded(address acco ...
•    - function balanceOfPhantom(address acc ...
•    - function balanceOfRewarded(address ac ...
•    - function statusOf(address account, ui ...
•  contract PoolSetters is PoolState, ... *
•    - function pause()
•    - function incrementBalanceOfBonded(add ...
•    - function decrementBalanceOfBonded(add ...
•    - function incrementBalanceOfStaged(add ...
•    - function decrementBalanceOfStaged(add ...
•    - function incrementBalanceOfClaimable( ...
•    - function decrementBalanceOfClaimable( ...
•    - function incrementBalanceOfPhantom(ad ...
•    - function decrementBalanceOfPhantom(ad ...
•    - function unfreeze(address account, ui ...
• interface IUniswapV2Pair
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transfer(address to, uint va ...
•    - function transferFrom(address from, a ...
•    - function DOMAIN_SEPARATOR()
•    - function PERMIT_TYPEHASH()
•    - function nonces(address owner)
•    - function permit(address owner, addres ...
•    - function MINIMUM_LIQUIDITY()
•    - function factory()
•    - function token0()
•    - function token1()
•    - function getReserves()
•    - function price0CumulativeLast()
•    - function price1CumulativeLast()
•    - function kLast()
•    - function mint(address to)
•    - function burn(address to)
•    - function swap(uint amount0Out, uint a ...
•    - function skim(address to)
•    - function sync()
•    - function initialize(address, address)
• library UniswapV2Library
•    - function sortTokens(address tokenA, a ...
•    - function pairFor(address factory, add ...
•    - function getReserves(address factory, ...
•    - function quote(uint amountA, uint res ...
•  contract Pool is PoolSetters *
•    - function addLiquidity(uint256 goldAmo ...
•    - function getReserves(address tokenA, ...
•    - function deposit(uint256 value)
•    - function withdraw(uint256 value)
•    - function claim(uint256 value)
•    - function unfreeze(address account)
•    - function bond(uint256 value)
•    - function unbond(uint256 value)
•    - function provide(uint256 value)
•    - function emergencyWithdraw(address to ...
•    - function emergencyPause()
•    - function balanceCheck()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-12-27
*/

pragma solidity ^0.5.17;
pragma experimental ABIEncoderV2;

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

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


/**
 * @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: contracts/external/Require.sol


/**
 * @title Require
 * @author dYdX
 *
 * Stringifies parameters to pretty-print revert messages. Costs more gas than regular require()
 */
library Require {

    // ============ Constants ============

    uint256 constant ASCII_ZERO = 48; // '0'
    uint256 constant ASCII_RELATIVE_ZERO = 87; // 'a' - 10
    uint256 constant ASCII_LOWER_EX = 120; // 'x'
    bytes2 constant COLON = 0x3a20; // ': '
    bytes2 constant COMMA = 0x2c20; // ', '
    bytes2 constant LPAREN = 0x203c; // ' <'
    byte constant RPAREN = 0x3e; // '>'
    uint256 constant FOUR_BIT_MASK = 0xf;

    // ============ Library Functions ============

    function that(
        bool must,
        bytes32 file,
        bytes32 reason
    )
    internal
    pure
    {
        if (!must) {
            revert(
                string(
                    abi.encodePacked(
                        stringifyTruncated(file),
                        COLON,
                        stringifyTruncated(reason)
                    )
                )
            );
        }
    }

    function that(
        bool must,
        bytes32 file,
        bytes32 reason,
        uint256 payloadA
    )
    internal
    pure
    {
        if (!must) {
            revert(
                string(
                    abi.encodePacked(
                        stringifyTruncated(file),
                        COLON,
                        stringifyTruncated(reason),
                        LPAREN,
                        stringify(payloadA),
                        RPAREN
                    )
                )
            );
        }
    }

    function that(
        bool must,
        bytes32 file,
        bytes32 reason,
        uint256 payloadA,
        uint256 payloadB
    )
    internal
    pure
    {
        if (!must) {
            revert(
                string(
                    abi.encodePacked(
                        stringifyTruncated(file),
                        COLON,
                        stringifyTruncated(reason),
                        LPAREN,
                        stringify(payloadA),
                        COMMA,
                        stringify(payloadB),
                        RPAREN
                    )
                )
            );
        }
    }

    function that(
        bool must,
        bytes32 file,
        bytes32 reason,
        address payloadA
    )
    internal
    pure
    {
        if (!must) {
            revert(
                string(
                    abi.encodePacked(
                        stringifyTruncated(file),
                        COLON,
                        stringifyTruncated(reason),
                        LPAREN,
                        stringify(payloadA),
                        RPAREN
                    )
                )
            );
        }
    }

    function that(
        bool must,
        bytes32 file,
        bytes32 reason,
        address payloadA,
        uint256 payloadB
    )
    internal
    pure
    {
        if (!must) {
            revert(
                string(
                    abi.encodePacked(
                        stringifyTruncated(file),
                        COLON,
                        stringifyTruncated(reason),
                        LPAREN,
                        stringify(payloadA),
                        COMMA,
                        stringify(payloadB),
                        RPAREN
                    )
                )
            );
        }
    }

    function that(
        bool must,
        bytes32 file,
        bytes32 reason,
        address payloadA,
        uint256 payloadB,
        uint256 payloadC
    )
    internal
    pure
    {
        if (!must) {
            revert(
                string(
                    abi.encodePacked(
                        stringifyTruncated(file),
                        COLON,
                        stringifyTruncated(reason),
                        LPAREN,
                        stringify(payloadA),
                        COMMA,
                        stringify(payloadB),
                        COMMA,
                        stringify(payloadC),
                        RPAREN
                    )
                )
            );
        }
    }

    function that(
        bool must,
        bytes32 file,
        bytes32 reason,
        bytes32 payloadA
    )
    internal
    pure
    {
        if (!must) {
            revert(
                string(
                    abi.encodePacked(
                        stringifyTruncated(file),
                        COLON,
                        stringifyTruncated(reason),
                        LPAREN,
                        stringify(payloadA),
                        RPAREN
                    )
                )
            );
        }
    }

    function that(
        bool must,
        bytes32 file,
        bytes32 reason,
        bytes32 payloadA,
        uint256 payloadB,
        uint256 payloadC
    )
    internal
    pure
    {
        if (!must) {
            revert(
                string(
                    abi.encodePacked(
                        stringifyTruncated(file),
                        COLON,
                        stringifyTruncated(reason),
                        LPAREN,
                        stringify(payloadA),
                        COMMA,
                        stringify(payloadB),
                        COMMA,
                        stringify(payloadC),
                        RPAREN
                    )
                )
            );
        }
    }

    // ============ Private Functions ============

    function stringifyTruncated(
        bytes32 input
    )
    private
    pure
    returns (bytes memory)
    {
        // put the input bytes into the result
        bytes memory result = abi.encodePacked(input);

        // determine the length of the input by finding the location of the last non-zero byte
        for (uint256 i = 32; i > 0; ) {
            // reverse-for-loops with unsigned integer
            /* solium-disable-next-line security/no-modify-for-iter-var */
            i--;

            // find the last non-zero byte in order to determine the length
            if (result[i] != 0) {
                uint256 length = i + 1;

                /* solium-disable-next-line security/no-inline-assembly */
                assembly {
                    mstore(result, length) // r.length = length;
                }

                return result;
            }
        }

        // all bytes are zero
        return new bytes(0);
    }

    function stringify(
        uint256 input
    )
    private
    pure
    returns (bytes memory)
    {
        if (input == 0) {
            return "0";
        }

        // get the final string length
        uint256 j = input;
        uint256 length;
        while (j != 0) {
            length++;
            j /= 10;
        }

        // allocate the string
        bytes memory bstr = new bytes(length);

        // populate the string starting with the least-significant character
        j = input;
        for (uint256 i = length; i > 0; ) {
            // reverse-for-loops with unsigned integer
            /* solium-disable-next-line security/no-modify-for-iter-var */
            i--;

            // take last decimal digit
            bstr[i] = byte(uint8(ASCII_ZERO + (j % 10)));

            // remove the last decimal digit
            j /= 10;
        }

        return bstr;
    }

    function stringify(
        address input
    )
    private
    pure
    returns (bytes memory)
    {
        uint256 z = uint256(input);

        // addresses are "0x" followed by 20 bytes of data which take up 2 characters each
        bytes memory result = new bytes(42);

        // populate the result with "0x"
        result[0] = byte(uint8(ASCII_ZERO));
        result[1] = byte(uint8(ASCII_LOWER_EX));

        // for each byte (starting from the lowest byte), populate the result with two characters
        for (uint256 i = 0; i < 20; i++) {
            // each byte takes two characters
            uint256 shift = i * 2;

            // populate the least-significant character
            result[41 - shift] = char(z & FOUR_BIT_MASK);
            z = z >> 4;

            // populate the most-significant character
            result[40 - shift] = char(z & FOUR_BIT_MASK);
            z = z >> 4;
        }

        return result;
    }

    function stringify(
        bytes32 input
    )
    private
    pure
    returns (bytes memory)
    {
        uint256 z = uint256(input);

        // bytes32 are "0x" followed by 32 bytes of data which take up 2 characters each
        bytes memory result = new bytes(66);

        // populate the result with "0x"
        result[0] = byte(uint8(ASCII_ZERO));
        result[1] = byte(uint8(ASCII_LOWER_EX));

        // for each byte (starting from the lowest byte), populate the result with two characters
        for (uint256 i = 0; i < 32; i++) {
            // each byte takes two characters
            uint256 shift = i * 2;

            // populate the least-significant character
            result[65 - shift] = char(z & FOUR_BIT_MASK);
            z = z >> 4;

            // populate the most-significant character
            result[64 - shift] = char(z & FOUR_BIT_MASK);
            z = z >> 4;
        }

        return result;
    }

    function char(
        uint256 input
    )
    private
    pure
    returns (byte)
    {
        // return ASCII digit (0-9)
        if (input < 10) {
            return byte(uint8(input + ASCII_ZERO));
        }

        // return ASCII letter (a-f)
        return byte(uint8(input + ASCII_RELATIVE_ZERO));
    }
}

// File: contracts/external/Decimal.sol

/**
 * @title Decimal
 * @author dYdX
 *
 * Library that defines a fixed-point number with 18 decimal places.
 */
library Decimal {
    using SafeMath for uint256;

    // ============ Constants ============

    uint256 constant BASE = 10**18;

    // ============ Structs ============


    struct D256 {
        uint256 value;
    }

    // ============ Static Functions ============

    function zero()
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: 0 });
    }

    function one()
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: BASE });
    }

    function from(
        uint256 a
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: a.mul(BASE) });
    }

    function ratio(
        uint256 a,
        uint256 b
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: getPartial(a, BASE, b) });
    }

    // ============ Self Functions ============

    function add(
        D256 memory self,
        uint256 b
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: self.value.add(b.mul(BASE)) });
    }

    function sub(
        D256 memory self,
        uint256 b
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: self.value.sub(b.mul(BASE)) });
    }

    function sub(
        D256 memory self,
        uint256 b,
        string memory reason
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: self.value.sub(b.mul(BASE), reason) });
    }

    function mul(
        D256 memory self,
        uint256 b
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: self.value.mul(b) });
    }

    function div(
        D256 memory self,
        uint256 b
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: self.value.div(b) });
    }

    function pow(
        D256 memory self,
        uint256 b
    )
    internal
    pure
    returns (D256 memory)
    {
        if (b == 0) {
            return from(1);
        }

        D256 memory temp = D256({ value: self.value });
        for (uint256 i = 1; i < b; i++) {
            temp = mul(temp, self);
        }

        return temp;
    }

    function add(
        D256 memory self,
        D256 memory b
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: self.value.add(b.value) });
    }

    function sub(
        D256 memory self,
        D256 memory b
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: self.value.sub(b.value) });
    }

    function sub(
        D256 memory self,
        D256 memory b,
        string memory reason
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: self.value.sub(b.value, reason) });
    }

    function mul(
        D256 memory self,
        D256 memory b
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: getPartial(self.value, b.value, BASE) });
    }

    function div(
        D256 memory self,
        D256 memory b
    )
    internal
    pure
    returns (D256 memory)
    {
        return D256({ value: getPartial(self.value, BASE, b.value) });
    }

    function equals(D256 memory self, D256 memory b) internal pure returns (bool) {
        return self.value == b.value;
    }

    function greaterThan(D256 memory self, D256 memory b) internal pure returns (bool) {
        return compareTo(self, b) == 2;
    }

    function lessThan(D256 memory self, D256 memory b) internal pure returns (bool) {
        return compareTo(self, b) == 0;
    }

    function greaterThanOrEqualTo(D256 memory self, D256 memory b) internal pure returns (bool) {
        return compareTo(self, b) > 0;
    }

    function lessThanOrEqualTo(D256 memory self, D256 memory b) internal pure returns (bool) {
        return compareTo(self, b) < 2;
    }

    function isZero(D256 memory self) internal pure returns (bool) {
        return self.value == 0;
    }

    function asUint256(D256 memory self) internal pure returns (uint256) {
        return self.value.div(BASE);
    }

    // ============ Core Methods ============

    function getPartial(
        uint256 target,
        uint256 numerator,
        uint256 denominator
    )
    private
    pure
    returns (uint256)
    {
        return target.mul(numerator).div(denominator);
    }

    function compareTo(
        D256 memory a,
        D256 memory b
    )
    private
    pure
    returns (uint256)
    {
        if (a.value == b.value) {
            return 1;
        }
        return a.value > b.value ? 2 : 0;
    }
}

// File: contracts/Constants.sol


library Constants {
    /* Chain */
    uint256 private constant CHAIN_ID = 1; // Mainnet

    /* Bootstrapping */
    uint256 private constant BOOTSTRAPPING_PERIOD = 56; // 14 days
    uint256 private constant BOOTSTRAPPING_PRICE = 11e17; // ESG price == 1.10 * sXAU

    /* Oracle */
    address private constant sXAU = address(0x261EfCdD24CeA98652B9700800a13DfBca4103fF);
    uint256 private constant ORACLE_RESERVE_MINIMUM = 1e18;

    /* Bonding */
    uint256 private constant INITIAL_STAKE_MULTIPLE = 1e6; // 100 ESG -> 100M ESGS

    /* Epoch */
    struct EpochStrategy {
        uint256 offset;
        uint256 start;
        uint256 period;
    }

    uint256 private constant EPOCH_START = 1609027200; // 2020-12-27T00:00:00+00:00
    uint256 private constant EPOCH_OFFSET = 0;
    uint256 private constant EPOCH_PERIOD = 21600; // 6 hours

    /* Governance */
    uint256 private constant GOVERNANCE_PERIOD = 9; // 9 epochs
    uint256 private constant GOVERNANCE_EXPIRATION = 2; // 2 + 1 epochs
    uint256 private constant GOVERNANCE_QUORUM = 20e16; // 20%
    uint256 private constant GOVERNANCE_PROPOSAL_THRESHOLD = 5e15; // 0.5%
    uint256 private constant GOVERNANCE_SUPER_MAJORITY = 66e16; // 66%
    uint256 private constant GOVERNANCE_EMERGENCY_DELAY = 6; // 6 epochs

    /* DAO */
    uint256 private constant ADVANCE_INCENTIVE = 1e17; // 0.1 ESG
    uint256 private constant DAO_EXIT_LOCKUP_EPOCHS = 20; // 5 days

    /* Pool */
    uint256 private constant POOL_EXIT_LOCKUP_EPOCHS = 8; // 2 days

    /* Market */
    uint256 private constant COUPON_EXPIRATION = 120; // 30 days
    uint256 private constant DEBT_RATIO_CAP = 35e16; // 35%

    /* Regulator */
    uint256 private constant SUPPLY_CHANGE_LIMIT = 1e17; // 10%
    uint256 private constant COUPON_SUPPLY_CHANGE_LIMIT = 6e16; // 6%
    uint256 private constant ORACLE_POOL_RATIO = 20; // 20%
    uint256 private constant TREASURY_RATIO = 250; // 2.5%, until TREASURY_ADDRESS is set, this portion is sent to LP

    // TODO: vote on recipient
    address private constant TREASURY_ADDRESS = address(0x0000000000000000000000000000000000000000);

    function getSXAUAddress() internal pure returns (address) {
        return sXAU;
    }

    function getOracleReserveMinimum() internal pure returns (uint256) {
        return ORACLE_RESERVE_MINIMUM;
    }

    function getCurrentEpochStrategy() internal pure returns (EpochStrategy memory) {
        return EpochStrategy({
            offset: EPOCH_OFFSET,
            start: EPOCH_START,
            period: EPOCH_PERIOD
        });
    }

    function getInitialStakeMultiple() internal pure returns (uint256) {
        return INITIAL_STAKE_MULTIPLE;
    }

    function getBootstrappingPeriod() internal pure returns (uint256) {
        return BOOTSTRAPPING_PERIOD;
    }

    function getBootstrappingPrice() internal pure returns (Decimal.D256 memory) {
        return Decimal.D256({value: BOOTSTRAPPING_PRICE});
    }

    function getGovernancePeriod() internal pure returns (uint256) {
        return GOVERNANCE_PERIOD;
    }

    function getGovernanceExpiration() internal pure returns (uint256) {
        return GOVERNANCE_EXPIRATION;
    }

    function getGovernanceQuorum() internal pure returns (Decimal.D256 memory) {
        return Decimal.D256({value: GOVERNANCE_QUORUM});
    }

    function getGovernanceProposalThreshold() internal pure returns (Decimal.D256 memory) {
        return Decimal.D256({value: GOVERNANCE_PROPOSAL_THRESHOLD});
    }

    function getGovernanceSuperMajority() internal pure returns (Decimal.D256 memory) {
        return Decimal.D256({value: GOVERNANCE_SUPER_MAJORITY});
    }

    function getGovernanceEmergencyDelay() internal pure returns (uint256) {
        return GOVERNANCE_EMERGENCY_DELAY;
    }

    function getAdvanceIncentive() internal pure returns (uint256) {
        return ADVANCE_INCENTIVE;
    }

    function getDAOExitLockupEpochs() internal pure returns (uint256) {
        return DAO_EXIT_LOCKUP_EPOCHS;
    }

    function getPoolExitLockupEpochs() internal pure returns (uint256) {
        return POOL_EXIT_LOCKUP_EPOCHS;
    }

    function getCouponExpiration() internal pure returns (uint256) {
        return COUPON_EXPIRATION;
    }

    function getDebtRatioCap() internal pure returns (Decimal.D256 memory) {
        return Decimal.D256({value: DEBT_RATIO_CAP});
    }

    function getSupplyChangeLimit() internal pure returns (Decimal.D256 memory) {
        return Decimal.D256({value: SUPPLY_CHANGE_LIMIT});
    }

    function getCouponSupplyChangeLimit() internal pure returns (Decimal.D256 memory) {
        return Decimal.D256({value: COUPON_SUPPLY_CHANGE_LIMIT});
    }

    function getOraclePoolRatio() internal pure returns (uint256) {
        return ORACLE_POOL_RATIO;
    }

    function getTreasuryRatio() internal pure returns (uint256) {
        return TREASURY_RATIO;
    }

    function getChainId() internal pure returns (uint256) {
        return CHAIN_ID;
    }

    function getTreasuryAddress() internal pure returns (address) {
        return TREASURY_ADDRESS;
    }
}

// File: contracts/token/IGold.sol


contract IGold is IERC20 {
    function burn(uint256 amount) public;
    function burnFrom(address account, uint256 amount) public;
    function mint(address account, uint256 amount) public returns (bool);
}

// File: contracts/oracle/IDAO.sol


contract IDAO {
    function epoch() external view returns (uint256);
}

// File: contracts/oracle/PoolState.sol


contract PoolAccount {
    enum Status {
        Frozen,
        Fluid,
        Locked
    }

    struct State {
        uint256 staged;
        uint256 claimable;
        uint256 bonded;
        uint256 phantom;
        uint256 fluidUntil;
    }
}

contract PoolStorage {
    struct Provider {
        IDAO dao;
        IGold gold;
        IERC20 univ2;
    }

    struct Balance {
        uint256 staged;
        uint256 claimable;
        uint256 bonded;
        uint256 phantom;
    }

    struct State {
        Balance balance;
        Provider provider;
        bool paused;

        mapping(address => PoolAccount.State) accounts;
    }
}

contract PoolState {
    PoolStorage.State _state;
}

// File: contracts/oracle/PoolGetters.sol



contract PoolGetters is PoolState {
    using SafeMath for uint256;

    /**
     * Global
     */

    function sXAU() public view returns (address) {
        return Constants.getSXAUAddress();
    }

    function dao() public view returns (IDAO) {
        return _state.provider.dao;
    }

    function gold() public view returns (IGold) {
        return _state.provider.gold;
    }

    function univ2() public view returns (IERC20) {
        return _state.provider.univ2;
    }

    function totalBonded() public view returns (uint256) {
        return _state.balance.bonded;
    }

    function totalStaged() public view returns (uint256) {
        return _state.balance.staged;
    }

    function totalClaimable() public view returns (uint256) {
        return _state.balance.claimable;
    }

    function totalPhantom() public view returns (uint256) {
        return _state.balance.phantom;
    }

    function totalRewarded(IGold gold) public view returns (uint256) {
        return gold.balanceOf(address(this)).sub(totalClaimable());
    }

    function paused() public view returns (bool) {
        return _state.paused;
    }

    /**
     * Account
     */

    function balanceOfStaged(address account) public view returns (uint256) {
        return _state.accounts[account].staged;
    }

    function balanceOfClaimable(address account) public view returns (uint256) {
        return _state.accounts[account].claimable;
    }

    function balanceOfBonded(address account) public view returns (uint256) {
        return _state.accounts[account].bonded;
    }

    function balanceOfPhantom(address account) public view returns (uint256) {
        return _state.accounts[account].phantom;
    }


    function balanceOfRewarded(address account, IGold gold) public view returns (uint256) {
        uint256 totalBonded = totalBonded();
        if (totalBonded == 0) {
            return 0;
        }

        uint256 totalRewardedWithPhantom = totalRewarded(gold).add(totalPhantom());
        uint256 balanceOfRewardedWithPhantom = totalRewardedWithPhantom
        .mul(balanceOfBonded(account))
        .div(totalBonded);

        uint256 balanceOfPhantom = balanceOfPhantom(account);
        if (balanceOfRewardedWithPhantom > balanceOfPhantom) {
            return balanceOfRewardedWithPhantom.sub(balanceOfPhantom);
        }
        return 0;
    }

    function statusOf(address account, uint256 epoch) public view returns (PoolAccount.Status) {
        return epoch >= _state.accounts[account].fluidUntil ?
        PoolAccount.Status.Frozen :
        PoolAccount.Status.Fluid;
    }
}

// File: contracts/oracle/PoolSetters.sol



contract PoolSetters is PoolState, PoolGetters {
    using SafeMath for uint256;

    /**
     * Global
     */

    function pause() internal {
        _state.paused = true;
    }

    /**
     * Account
     */

    function incrementBalanceOfBonded(address account, uint256 amount) internal {
        _state.accounts[account].bonded = _state.accounts[account].bonded.add(amount);
        _state.balance.bonded = _state.balance.bonded.add(amount);
    }

    function decrementBalanceOfBonded(address account, uint256 amount, string memory reason) internal {
        _state.accounts[account].bonded = _state.accounts[account].bonded.sub(amount, reason);
        _state.balance.bonded = _state.balance.bonded.sub(amount, reason);
    }

    function incrementBalanceOfStaged(address account, uint256 amount) internal {
        _state.accounts[account].staged = _state.accounts[account].staged.add(amount);
        _state.balance.staged = _state.balance.staged.add(amount);
    }

    function decrementBalanceOfStaged(address account, uint256 amount, string memory reason) internal {
        _state.accounts[account].staged = _state.accounts[account].staged.sub(amount, reason);
        _state.balance.staged = _state.balance.staged.sub(amount, reason);
    }

    function incrementBalanceOfClaimable(address account, uint256 amount) internal {
        _state.accounts[account].claimable = _state.accounts[account].claimable.add(amount);
        _state.balance.claimable = _state.balance.claimable.add(amount);
    }

    function decrementBalanceOfClaimable(address account, uint256 amount, string memory reason) internal {
        _state.accounts[account].claimable = _state.accounts[account].claimable.sub(amount, reason);
        _state.balance.claimable = _state.balance.claimable.sub(amount, reason);
    }

    function incrementBalanceOfPhantom(address account, uint256 amount) internal {
        _state.accounts[account].phantom = _state.accounts[account].phantom.add(amount);
        _state.balance.phantom = _state.balance.phantom.add(amount);
    }

    function decrementBalanceOfPhantom(address account, uint256 amount, string memory reason) internal {
        _state.accounts[account].phantom = _state.accounts[account].phantom.sub(amount, reason);
        _state.balance.phantom = _state.balance.phantom.sub(amount, reason);
    }

    function unfreeze(address account, uint256 epoch) internal {
        _state.accounts[account].fluidUntil = epoch.add(Constants.getPoolExitLockupEpochs());
    }
}

// File: @uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol


interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

// File: contracts/external/UniswapV2Library.sol




library UniswapV2Library {
    using SafeMath for uint;

    // returns sorted token addresses, used to handle return values from pairs sorted in this order
    function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
        require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
        (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
    }

    // calculates the CREATE2 address for a pair without making any external calls
    function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
        (address token0, address token1) = sortTokens(tokenA, tokenB);
        pair = address(uint(keccak256(abi.encodePacked(
                hex'ff',
                factory,
                keccak256(abi.encodePacked(token0, token1)),
                hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash
            ))));
    }

    // fetches and sorts the reserves for a pair
    function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
        (address token0,) = sortTokens(tokenA, tokenB);
        (uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
        (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
    }

    // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
    function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
        require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
        require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
        amountB = amountA.mul(reserveB) / reserveA;
    }
}

// File: contracts/oracle/Pool.sol








contract Pool is PoolSetters {
    using SafeMath for uint256;

    constructor(address gold, address univ2) public {
        _state.provider.dao = IDAO(msg.sender);
        _state.provider.gold = IGold(gold);
        _state.provider.univ2 = IERC20(univ2);
    }

    address private constant UNISWAP_FACTORY = address(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);

    function addLiquidity(uint256 goldAmount) internal returns (uint256, uint256) {
        (address gold, address sXAU) = (address(_state.provider.gold), sXAU());
        (uint reserveA, uint reserveB) = getReserves(gold, sXAU);

        uint256 sXAUAmount = (reserveA == 0 && reserveB == 0) ?
        goldAmount :
        UniswapV2Library.quote(goldAmount, reserveA, reserveB);

        address pair = address(_state.provider.univ2);
        IERC20(gold).transfer(pair, goldAmount);
        IERC20(sXAU).transferFrom(msg.sender, pair, sXAUAmount);
        return (sXAUAmount, IUniswapV2Pair(pair).mint(address(this)));
    }

    // overridable for testing
    function getReserves(address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
        (address token0,) = UniswapV2Library.sortTokens(tokenA, tokenB);
        (uint reserve0, uint reserve1,) = IUniswapV2Pair(UniswapV2Library.pairFor(UNISWAP_FACTORY, tokenA, tokenB)).getReserves();
        (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
    }

    bytes32 private constant FILE = "Pool";

    event Deposit(address indexed account, uint256 value);
    event Withdraw(address indexed account, uint256 value);
    event Claim(address indexed account, uint256 value);
    event Bond(address indexed account, uint256 start, uint256 value);
    event Unbond(address indexed account, uint256 start, uint256 value, uint256 newClaimable);
    event Provide(address indexed account, uint256 value, uint256 lessSXAU, uint256 newUniv2);

    function deposit(uint256 value) external onlyFrozen(msg.sender) notPaused {
        _state.provider.univ2.transferFrom(msg.sender, address(this), value);
        incrementBalanceOfStaged(msg.sender, value);

        balanceCheck();

        emit Deposit(msg.sender, value);
    }

    function withdraw(uint256 value) external onlyFrozen(msg.sender) {
        _state.provider.univ2.transfer(msg.sender, value);
        decrementBalanceOfStaged(msg.sender, value, "Pool: insufficient staged balance");

        balanceCheck();

        emit Withdraw(msg.sender, value);
    }

    function claim(uint256 value) external onlyFrozen(msg.sender) {
        _state.provider.gold.transfer(msg.sender, value);
        decrementBalanceOfClaimable(msg.sender, value, "Pool: insufficient claimable balance");

        balanceCheck();

        emit Claim(msg.sender, value);
    }

    function unfreeze(address account) internal {
        super.unfreeze(account, _state.provider.dao.epoch());
    }

    function bond(uint256 value) external notPaused {
        unfreeze(msg.sender);

        uint256 totalRewardedWithPhantom = totalRewarded(_state.provider.gold).add(totalPhantom());
        uint256 newPhantom = totalBonded() == 0 ?
        totalRewarded(_state.provider.gold) == 0 ? Constants.getInitialStakeMultiple().mul(value) : 0 :
        totalRewardedWithPhantom.mul(value).div(totalBonded());

        incrementBalanceOfBonded(msg.sender, value);
        incrementBalanceOfPhantom(msg.sender, newPhantom);
        decrementBalanceOfStaged(msg.sender, value, "Pool: insufficient staged balance");

        balanceCheck();

        emit Bond(msg.sender, _state.provider.dao.epoch().add(1), value);
    }

    function unbond(uint256 value) external {
        unfreeze(msg.sender);

        uint256 balanceOfBonded = balanceOfBonded(msg.sender);
        Require.that(
            balanceOfBonded > 0,
            FILE,
            "insufficient bonded balance"
        );

        uint256 newClaimable = balanceOfRewarded(msg.sender, _state.provider.gold).mul(value).div(balanceOfBonded);
        uint256 lessPhantom = balanceOfPhantom(msg.sender).mul(value).div(balanceOfBonded);

        incrementBalanceOfStaged(msg.sender, value);
        incrementBalanceOfClaimable(msg.sender, newClaimable);
        decrementBalanceOfBonded(msg.sender, value, "Pool: insufficient bonded balance");
        decrementBalanceOfPhantom(msg.sender, lessPhantom, "Pool: insufficient phantom balance");

        balanceCheck();

        emit Unbond(msg.sender, _state.provider.dao.epoch().add(1), value, newClaimable);
    }

    function provide(uint256 value) external onlyFrozen(msg.sender) notPaused {
        Require.that(
            totalBonded() > 0,
            FILE,
            "insufficient total bonded"
        );

        Require.that(
            totalRewarded(_state.provider.gold) > 0,
            FILE,
            "insufficient total rewarded"
        );

        Require.that(
            balanceOfRewarded(msg.sender, _state.provider.gold) >= value,
            FILE,
            "insufficient rewarded balance"
        );

        (uint256 lessSXAU, uint256 newUniv2) = addLiquidity(value);

        uint256 totalRewardedWithPhantom = totalRewarded(_state.provider.gold).add(totalPhantom()).add(value);
        uint256 newPhantomFromBonded = totalRewardedWithPhantom.mul(newUniv2).div(totalBonded());

        incrementBalanceOfBonded(msg.sender, newUniv2);
        incrementBalanceOfPhantom(msg.sender, value.add(newPhantomFromBonded));


        balanceCheck();

        emit Provide(msg.sender, value, lessSXAU, newUniv2);
    }

    function emergencyWithdraw(address token, uint256 value) external onlyDao {
        IERC20(token).transfer(address(_state.provider.dao), value);
    }

    function emergencyPause() external onlyDao {
        pause();
    }

    function balanceCheck() private {
        Require.that(
            _state.provider.univ2.balanceOf(address(this)) >= totalStaged().add(totalBonded()),
            FILE,
            "Inconsistent UNI-V2 balances"
        );
    }

    modifier onlyFrozen(address account) {
        Require.that(
            statusOf(account, _state.provider.dao.epoch()) == PoolAccount.Status.Frozen,
            FILE,
            "Not frozen"
        );

        _;
    }

    modifier onlyDao() {
        Require.that(
            msg.sender == address(_state.provider.dao),
            FILE,
            "Not dao"
        );

        _;
    }

    modifier notPaused() {
        Require.that(
            !paused(),
            FILE,
            "Paused"
        );

        _;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"gold","type":"address"},{"internalType":"address","name":"univ2","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"start","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Bond","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lessSXAU","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newUniv2","type":"uint256"}],"name":"Provide","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"start","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newClaimable","type":"uint256"}],"name":"Unbond","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Withdraw","type":"event"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOfBonded","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOfClaimable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOfPhantom","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"contract IGold","name":"gold","type":"address"}],"name":"balanceOfRewarded","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOfStaged","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"bond","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"claim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"dao","outputs":[{"internalType":"contract IDAO","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"deposit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"emergencyPause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"gold","outputs":[{"internalType":"contract IGold","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"provide","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"sXAU","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"epoch","type":"uint256"}],"name":"statusOf","outputs":[{"internalType":"enum PoolAccount.Status","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalBonded","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalClaimable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalPhantom","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"contract IGold","name":"gold","type":"address"}],"name":"totalRewarded","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalStaged","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"unbond","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"univ2","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000005cf9242493be1411b93d064ca2e468961bbb592400000000000000000000000094926da4c34c3a379426b51af154fcbf24c2026a

-----Decoded View---------------
Arg [0] : gold (address): 0x5cf9242493bE1411b93d064CA2e468961BBb5924
Arg [1] : univ2 (address): 0x94926Da4C34C3a379426B51af154fcbF24c2026A

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000005cf9242493be1411b93d064ca2e468961bbb5924
Arg [1] : 00000000000000000000000094926da4c34c3a379426b51af154fcbf24c2026a

40062:6759:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;40062:6759:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30239:98;;;:::i;:::-;;;;;;;;;;;;;;;;31494:135;;;;;;;;;:::i;:::-;;;;;;;;43786:918;;;;;;;;;:::i;:::-;;31774:131;;;;;;;;;:::i;42326:296::-;;;;;;;;;:::i;44712:1055::-;;;;;;;;;:::i;42630:295::-;;;;;;;;;:::i;30345:87::-;;;:::i;:::-;;;;;;;;30639:100;;;:::i;30855:106::-;;;:::i;45935:69::-;;;:::i;32589:234::-;;;;;;;;;:::i;:::-;;;;;;;;31229:84;;;:::i;:::-;;;;;;;;30538:93;;;:::i;31637:129::-;;;;;;;;;:::i;31357:::-;;;;;;;;;:::i;45775:152::-;;;;;;;;;:::i;43056:722::-;;;;;;;;;:::i;42032:286::-;;;;;;;;;:::i;30747:100::-;;;:::i;30969:102::-;;;:::i;31915:666::-;;;;;;;;;:::i;31079:142::-;;;;;;;;;:::i;30440:90::-;;;:::i;30239:98::-;30276:7;30303:26;:24;:26::i;:::-;30296:33;;30239:98;:::o;31494:135::-;-1:-1:-1;;;;;31587:24:0;;31560:7;31587:24;;;:15;:24;;;;;:34;;;31494:135;;;;:::o;43786:918::-;43837:20;43846:10;43837:8;:20::i;:::-;43870:23;43896:27;43912:10;43896:15;:27::i;:::-;43870:53;;43934:120;43979:1;43961:15;:19;-1:-1:-1;;;43934:120:0;:12;:120::i;:::-;44120:20;;44067;;44090:83;;44157:15;;44090:62;;44146:5;;44090:51;;44108:10;;-1:-1:-1;;;;;44120:20:0;44090:17;:51::i;:::-;:55;:62;:55;:62;:::i;:::-;:66;:83;:66;:83;:::i;:::-;44067:106;;44184:19;44206:60;44250:15;44206:39;44239:5;44206:28;44223:10;44206:16;:28::i;:60::-;44184:82;;44279:43;44304:10;44316:5;44279:24;:43::i;:::-;44333:53;44361:10;44373:12;44333:27;:53::i;:::-;44397:80;44422:10;44434:5;44397:80;;;;;;;;;;;;;;;;;:24;:80::i;:::-;44488:88;44514:10;44526:11;44488:88;;;;;;;;;;;;;;;;;:25;:88::i;:::-;44589:14;:12;:14::i;:::-;44640:15;:19;;:27;;;-1:-1:-1;;;44640:27:0;;;;44628:10;;44621:75;;44640:34;;44672:1;;-1:-1:-1;;;;;44640:19:0;;;;:25;;:27;;;;;;;;;;;;:19;:27;;;5:2:-1;;;;30:1;27;20:12;5:2;44640:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;44640:27:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;44640:27:0;;;;;;;;;:31;:34;:31;:34;:::i;:::-;44676:5;44683:12;44621:75;;;;;;;;;;;;;;;;;43786:918;;;;:::o;31774:131::-;-1:-1:-1;;;;;31865:24:0;31838:7;31865:24;;;:15;:24;;;;;:32;;;;31774:131::o;42326:296::-;42379:10;46303:159;46380:25;46330:75;46348:15;:19;;:27;;;-1:-1:-1;;;46348:27:0;;;;46330:46;;46339:7;;-1:-1:-1;;;;;46348:19:0;;:25;;:27;;;;;;;;;;;:19;:27;;;5:2:-1;;;;30:1;27;20:12;5:2;46348:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;46348:27:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;46348:27:0;;;;;;;;46330:46;:75;;;;;;;;;-1:-1:-1;;;;;;46303:12:0;:159::i;:::-;42402:21;;:49;;-1:-1:-1;;;42402:49:0;;-1:-1:-1;;;;;42402:21:0;;;;:30;;:49;;42433:10;;42445:5;;42402:15;:49;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42402:49:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;42402:49:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;42402:49:0;;;;;;;;;;42462:80;42487:10;42499:5;42462:80;;;;;;;;;;;;;;;;;:24;:80::i;:::-;42555:14;:12;:14::i;:::-;42596:10;-1:-1:-1;;;;;42587:27:0;;42608:5;42587:27;;;;;;;;;;;;;;;42326:296;;:::o;44712:1055::-;44764:10;46303:159;46380:25;46330:75;;46303:159;46707:89;46735:8;:6;:8::i;:::-;46734:9;-1:-1:-1;;;;;;46707:12:0;:89::i;:::-;44797:116;44840:1;44824:13;:11;:13::i;:::-;:17;-1:-1:-1;;;44797:116:0;:12;:116::i;:::-;44967:20;;44926:140;;44991:1;;44953:35;;-1:-1:-1;;;;;44967:20:0;44953:13;:35::i;:::-;:39;-1:-1:-1;;;44926:140:0;:12;:140::i;:::-;45136:20;;45079:163;;45161:5;;45106:51;;45124:10;;-1:-1:-1;;;;;45136:20:0;45106:17;:51::i;:::-;:60;;-1:-1:-1;;;45079:163:0;:12;:163::i;:::-;45256:16;45274;45294:19;45307:5;45294:12;:19::i;:::-;45255:58;;;;45326:32;45361:66;45421:5;45361:55;45401:14;:12;:14::i;:::-;45375:20;;45361:35;;-1:-1:-1;;;;;45375:20:0;45361:13;:35::i;:66::-;45326:101;;45438:28;45469:57;45512:13;:11;:13::i;:::-;45469:38;:24;45498:8;45469:38;:28;:38;:::i;:57::-;45438:88;;45539:46;45564:10;45576:8;45539:24;:46::i;:::-;45596:70;45622:10;45634:31;:5;45644:20;45634:31;:9;:31;:::i;:::-;45596:25;:70::i;:::-;45681:14;:12;:14::i;:::-;45721:10;-1:-1:-1;;;;;45713:46:0;;45733:5;45740:8;45750;45713:46;;;;;;;;;;;;;;;;;46809:1;;;;44712:1055;;:::o;42630:295::-;42680:10;46303:159;46380:25;46330:75;;46303:159;42703:20;;:48;;-1:-1:-1;;;42703:48:0;;-1:-1:-1;;;;;42703:20:0;;;;:29;;:48;;42733:10;;42745:5;;42703:15;:48;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42703:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;42703:48:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;42703:48:0;;;;;;;;;;42762:86;42790:10;42802:5;42762:86;;;;;;;;;;;;;;;;;:27;:86::i;:::-;42861:14;:12;:14::i;:::-;42899:10;-1:-1:-1;;;;;42893:24:0;;42911:5;42893:24;;;;;;;30345:87;30405:15;:19;-1:-1:-1;;;;;30405:19:0;30345:87;:::o;30639:100::-;30710:21;;30639:100;:::o;30855:106::-;30929:24;;30855:106;:::o;45935:69::-;46571:15;:19;46522:123;;-1:-1:-1;;;;;46571:19:0;46549:10;:42;-1:-1:-1;;;;;;46522:12:0;:123::i;:::-;45989:7;:5;:7::i;:::-;45935:69::o;32589:234::-;-1:-1:-1;;;;;32707:24:0;;32660:18;32707:24;;;:15;:24;;;;;:35;;;32698:44;;;:117;;32791:24;32698:117;;;32754:25;32698:117;32691:124;;32589:234;;;;;:::o;31229:84::-;31292:13;;;;31229:84;:::o;30538:93::-;30602:21;;-1:-1:-1;;;;;30602:21:0;30538:93;:::o;31637:129::-;-1:-1:-1;;;;;31727:24:0;31700:7;31727:24;;;:15;:24;;;;;:31;;;;31637:129::o;31357:::-;-1:-1:-1;;;;;31447:24:0;31420:7;31447:24;;;:15;:24;;;;;:31;;31357:129::o;45775:152::-;46571:15;:19;46522:123;;-1:-1:-1;;;;;46571:19:0;46549:10;:42;-1:-1:-1;;;;;;46522:12:0;:123::i;:::-;45891:15;:19;;45860:59;;-1:-1:-1;;;45860:59:0;;-1:-1:-1;;;;;45860:22:0;;;;;;:59;;45891:19;;;45913:5;;45860:59;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45860:59:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45860:59:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;45860:59:0;;;;;;;;;;45775:152;;:::o;43056:722::-;46707:89;46735:8;:6;:8::i;46707:89::-;43115:20;43124:10;43115:8;:20::i;:::-;43148:32;43183:55;43223:14;:12;:14::i;43183:55::-;43148:90;;43249:18;43270:13;:11;:13::i;:::-;:18;:189;;43405:54;43445:13;:11;:13::i;43405:54::-;43270:189;;;43314:20;;43300:35;;-1:-1:-1;;;;;43314:20:0;43300:13;:35::i;:::-;:40;:93;;43392:1;43300:93;;;43343:46;43383:5;43343:35;:33;:35::i;:46::-;43249:210;;43472:43;43497:10;43509:5;43472:24;:43::i;:::-;43526:49;43552:10;43564;43526:25;:49::i;:::-;43586:80;43611:10;43623:5;43586:80;;;;;;;;;;;;;;;;;:24;:80::i;:::-;43679:14;:12;:14::i;:::-;43728:15;:19;;:27;;;-1:-1:-1;;;43728:27:0;;;;43716:10;;43711:59;;43728:34;;43760:1;;-1:-1:-1;;;;;43728:19:0;;;;:25;;:27;;;;;;;;;;;;:19;:27;;;5:2:-1;;;;30:1;27;20:12;43728:34:0;43764:5;43711:59;;;;;;;;;;;;;;;;46809:1;;43056:722;:::o;42032:286::-;42084:10;46303:159;46380:25;46330:75;;46303:159;46707:89;46735:8;:6;:8::i;46707:89::-;42117:21;;:68;;-1:-1:-1;;;42117:68:0;;-1:-1:-1;;;;;42117:21:0;;;;:34;;:68;;42152:10;;42172:4;;42179:5;;42117:15;:68;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42117:68:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;42117:68:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;42117:68:0;;;;;;;;;;42196:43;42221:10;42233:5;42196:24;:43::i;:::-;42252:14;:12;:14::i;:::-;42292:10;-1:-1:-1;;;;;42284:26:0;;42304:5;42284:26;;;;;;;30747:100;30791:7;30818:21;30747:100;:::o;30969:102::-;31041:22;;30969:102;:::o;31915:666::-;31992:7;32012:19;32034:13;:11;:13::i;:::-;32012:35;-1:-1:-1;32062:16:0;32058:57;;32102:1;32095:8;;;;;32058:57;32127:32;32162:39;32186:14;:12;:14::i;:::-;32162:19;32176:4;32162:13;:19::i;:39::-;32127:74;;32212:36;32251:91;32330:11;32251:64;32290:24;32306:7;32290:15;:24::i;:::-;32251;;:64;:38;:64;:::i;:91::-;32212:130;;32355:24;32382:25;32399:7;32382:16;:25::i;:::-;32355:52;;32453:16;32422:28;:47;32418:137;;;32493:50;:28;32526:16;32493:50;:32;:50;:::i;:::-;32486:57;;;;;;;;32418:137;-1:-1:-1;32572:1:0;;31915:666;-1:-1:-1;;;;;;31915:666:0:o;31079:142::-;31135:7;31162:51;31196:16;:14;:16::i;:::-;31162:29;;-1:-1:-1;;;31162:29:0;;-1:-1:-1;;;;;31162:14:0;;;;;:29;;31185:4;;31162:29;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;31162:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;31162:29:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;31162:29:0;;;;;;;;;:33;:51;:33;:51;:::i;30440:90::-;30502:20;;-1:-1:-1;;;;;30502:20:0;30440:90;:::o;25846:88::-;23992:42;25846:88;:::o;42933:115::-;43012:15;:19;;:27;;;-1:-1:-1;;;43012:27:0;;;;42988:52;;43003:7;;-1:-1:-1;;;;;43012:19:0;;:25;;:27;;;;;;;;;;;:19;:27;;;5:2:-1;;;;30:1;27;20:12;5:2;43012:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;43012:27:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;43012:27:0;;;;;;;;;42988:14;:52::i;:::-;42933:115;:::o;9098:437::-;9232:4;9227:301;;9350:24;9369:4;9350:18;:24::i;:::-;-1:-1:-1;;;9433:26:0;9452:6;9433:18;:26::i;:::-;9307:175;;;;;;;;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;9307:175:0;;;;-1:-1:-1;;;9253:263:0;;;;;;;;;;;;;;;;2321:471;2379:7;2624:6;2620:47;;-1:-1:-1;2654:1:0;2647:8;;2620:47;2691:5;;;2695:1;2691;:5;:1;2715:5;;;;;:10;2707:56;;;;-1:-1:-1;;;2707:56:0;;;;;;;;3260:132;3318:7;3345:39;3349:1;3352;3345:39;;;;;;;;;;;;;;;;;:3;:39::i;33646:240::-;-1:-1:-1;;;;;33767:24:0;;:6;:24;;;:15;:24;;;;;:31;:43;;33803:6;33767:43;:35;:43;:::i;:::-;-1:-1:-1;;;;;33733:24:0;;:6;:24;;;:15;:24;;;;;:77;;;;33845:21;:33;;33871:6;33845:33;:25;:33;:::i;:::-;33821:6;:57;-1:-1:-1;;33646:240:0:o;34180:255::-;-1:-1:-1;;;;;34307:24:0;;:6;:24;;;:15;:24;;;;;:34;;;:46;;34346:6;34307:46;:38;:46;:::i;:::-;-1:-1:-1;;;;;34270:24:0;;:6;:24;;;:15;:24;;;;;:34;;;;:83;;;;34391:24;:36;;34420:6;34391:36;:28;:36;:::i;:::-;34364:24;:63;-1:-1:-1;;34180:255:0:o;33360:278::-;-1:-1:-1;;;;;33503:24:0;;:6;:24;;;:15;:24;;;;;:31;;;:51;;33539:6;33547;33503:51;:35;:51;:::i;:::-;-1:-1:-1;;;;;33469:24:0;;:6;:24;;;:15;:24;;;;;:31;;;;:85;;;;33589:21;:41;;33615:6;33623;33589:41;:25;:41;:::i;:::-;33565:21;:65;-1:-1:-1;;;33360:278:0:o;34997:283::-;-1:-1:-1;;;;;35142:24:0;;:6;:24;;;:15;:24;;;;;:32;;;:52;;35179:6;35187;35142:52;:36;:52;:::i;:::-;-1:-1:-1;;;;;35107:24:0;;:6;:24;;;:15;:24;;;;;:32;;;;:87;;;;35230:22;:42;;35257:6;35265;35230:42;:26;:42;:::i;:::-;35205:22;:67;-1:-1:-1;;;34997:283:0:o;46012:235::-;46055:184;46132:32;46150:13;:11;:13::i;:::-;46132;:11;:13::i;:32::-;46082:21;;:46;;-1:-1:-1;;;46082:46:0;;-1:-1:-1;;;;;46082:21:0;;;;:31;;:46;;46122:4;;46082:15;:46;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;46082:46:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;46082:46:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;46082:46:0;;;;;;;;;:82;;-1:-1:-1;;;46055:184:0;:12;:184::i;949:181::-;1007:7;1039:5;;;1063:6;;;;1055:46;;;;-1:-1:-1;;;1055:46:0;;;;;;;;33894:278;-1:-1:-1;;;;;34037:24:0;;:6;:24;;;:15;:24;;;;;:31;:51;;34073:6;34081;34037:51;:35;:51;:::i;:::-;-1:-1:-1;;;;;34003:24:0;;:6;:24;;;:15;:24;;;;;:85;;;;34123:21;:41;;34149:6;34157;34123:41;:25;:41;:::i;:::-;34099:6;:65;-1:-1:-1;;;33894:278:0:o;40442:634::-;40571:20;;40502:7;;;;;;;;-1:-1:-1;;;;;40571:20:0;40594:6;:4;:6::i;:::-;40531:70;;;;40613:13;40628;40645:23;40657:4;40663;40645:11;:23::i;:::-;40612:56;;;;40681:18;40703:8;40715:1;40703:13;:30;;;;-1:-1:-1;40720:13:0;;40703:30;40702:120;;40768:54;40791:10;40803:8;40813;40768:22;:54::i;:::-;40702:120;;;40746:10;40702:120;40858:21;;40891:39;;-1:-1:-1;;;40891:39:0;;40681:141;;-1:-1:-1;;;;;;40858:21:0;;;;40891;;;;;;:39;;40858:21;;40919:10;;40858:15;40891:39;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;40891:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;40891:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;40891:39:0;;;;;;;;;-1:-1:-1;40941:55:0;;-1:-1:-1;;;40941:55:0;;-1:-1:-1;;;;;40941:25:0;;;;;:55;;40967:10;;40979:4;;40985:10;;40941:55;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;40941:55:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;40941:55:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;40941:55:0;;;;;;;;;-1:-1:-1;41027:40:0;;-1:-1:-1;;;41027:40:0;;41015:10;;-1:-1:-1;;;;;41027:25:0;;;;;:40;;41061:4;;41027:40;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;41027:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;41027:40:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;41027:40:0;;;;;;;;;41007:61;;;;;;;;;;40442:634;;;:::o;33112:240::-;-1:-1:-1;;;;;33233:24:0;;:6;:24;;;:15;:24;;;;;:31;;;:43;;33269:6;33233:43;:35;:43;:::i;:::-;-1:-1:-1;;;;;33199:24:0;;:6;:24;;;:15;:24;;;;;:31;;;;:77;;;;33311:21;:33;;33337:6;33311:33;:25;:33;:::i;:::-;33287:21;:57;-1:-1:-1;;33112:240:0:o;34744:245::-;-1:-1:-1;;;;;34867:24:0;;:6;:24;;;:15;:24;;;;;:32;;;:44;;34904:6;34867:44;:36;:44;:::i;:::-;-1:-1:-1;;;;;34832:24:0;;:6;:24;;;:15;:24;;;;;:32;;;;:79;;;;34947:22;:34;;34974:6;34947:34;:26;:34;:::i;:::-;34922:22;:59;-1:-1:-1;;34744:245:0:o;34443:293::-;-1:-1:-1;;;;;34592:24:0;;:6;:24;;;:15;:24;;;;;:34;;;:54;;34631:6;34639;34592:54;:38;:54;:::i;:::-;-1:-1:-1;;;;;34555:24:0;;:6;:24;;;:15;:24;;;;;:34;;;;:91;;;;34684:24;:44;;34713:6;34721;34684:44;:28;:44;:::i;:::-;34657:24;:71;-1:-1:-1;;;34443:293:0:o;33003:65::-;33040:13;:20;;-1:-1:-1;;33040:20:0;33056:4;33040:20;;;33003:65::o;26308:115::-;24174:3;26308:115;:::o;1405:136::-;1463:7;1490:43;1494:1;1497;1490:43;;;;;;;;;;;;;;;;;:3;:43::i;35288:162::-;35396:46;35406:35;:33;:35::i;:::-;35396:5;;:46;:9;:46;:::i;:::-;-1:-1:-1;;;;;35358:24:0;;;:6;:24;;;:15;:24;;;;;:35;;:84;;;;-1:-1:-1;35288:162:0:o;14315:985::-;14411:12;14489:19;14528:5;14511:23;;;;;;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;14511:23:0;;;;-1:-1:-1;49:4;14643:587:0;14664:5;;14643:587;;14921:9;;-1:-1:-1;;14820:3:0;;;;14921:6;;14820:3;;14921:9;;;;;;;;;;-1:-1:-1;;;;;;14921:9:0;:14;14917:302;;14977:1;14973:5;15107:22;;15114:6;-1:-1:-1;15190:13:0;;14917:302;14643:587;;;-1:-1:-1;;15280:12:0;;;15290:1;15280:12;;;;;;;;;15273:19;-1:-1:-1;;14315:985:0:o;3922:345::-;4008:7;4110:12;4103:5;4095:28;;;;-1:-1:-1;;;4095:28:0;;;;;;;;;;;4134:9;4150:1;4146;:5;;;;;;;-1:-1:-1;;3922:345:0;;;;;;:::o;1878:192::-;1964:7;2000:12;1992:6;;;;1984:29;;;;-1:-1:-1;;;1984:29:0;;;;;;;;;;-1:-1:-1;;;2036:5:0;;;1878:192::o;41116:416::-;41192:13;41207;41234:14;41253:43;41281:6;41289;41253:27;:43::i;:::-;41233:63;;;41308:13;41323;41356:57;40390:42;41398:6;41406;41356:24;:57::i;:::-;-1:-1:-1;;;;;41341:85:0;;:87;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;41341:87:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;41341:87:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;41341:87:0;;;;;;;;;41307:121;-1:-1:-1;;;;;41307:121:0;;;-1:-1:-1;;;;;41307:121:0;;;41472:6;-1:-1:-1;;;;;41462:16:0;:6;-1:-1:-1;;;;;41462:16:0;;:62;;41505:8;41515;41462:62;;;41482:8;41492;41462:62;41439:85;;;;-1:-1:-1;41116:416:0;-1:-1:-1;;;;;;41116:416:0:o;39682:321::-;39764:12;39807:1;39797:7;:11;39789:61;;;;-1:-1:-1;;;39789:61:0;;;;;;;;;39880:1;39869:8;:12;:28;;;;;39896:1;39885:8;:12;39869:28;39861:81;;;;-1:-1:-1;;;39861:81:0;;;;;;;;;39987:8;39963:21;:7;39975:8;39963:21;:11;:21;:::i;:::-;:32;;;;;;;39682:321;-1:-1:-1;;;;39682:321:0:o;27792:116::-;25204:1;27792:116;:::o;38201:349::-;38276:14;38292;38337:6;-1:-1:-1;;;;;38327:16:0;:6;-1:-1:-1;;;;;38327:16:0;;;38319:66;;;;-1:-1:-1;;;38319:66:0;;;;;;;;;38424:6;-1:-1:-1;;;;;38415:15:0;:6;-1:-1:-1;;;;;38415:15:0;;:53;;38453:6;38461;38415:53;;;38434:6;38442;38415:53;38396:72;;-1:-1:-1;38396:72:0;-1:-1:-1;;;;;;38487:20:0;;38479:63;;;;-1:-1:-1;;;38479:63:0;;;;;;;;;38201:349;;;;;:::o;38642:478::-;38731:12;38757:14;38773;38791:26;38802:6;38810;38791:10;:26::i;:::-;38756:61;;;;38919:7;38972:6;38980;38955:32;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;38955:32:0;;;38945:43;;;;;;38858:251;;;;;;;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;38858:251:0;;;38848:262;;49:4:-1;38848:262:0;;;;;38642:478;-1:-1:-1;;;;;;38642:478:0:o;5:130:-1:-;72:20;;97:33;72:20;97:33;;142:128;217:13;;235:30;217:13;235:30;;277:158;358:20;;383:47;358:20;383:47;;442:134;520:13;;538:33;520:13;538:33;;583:130;650:20;;675:33;650:20;675:33;;720:134;798:13;;816:33;798:13;816:33;;861:132;938:13;;956:32;938:13;956:32;;1000:241;;1104:2;1092:9;1083:7;1079:23;1075:32;1072:2;;;1120:1;1117;1110:12;1072:2;1155:1;1172:53;1217:7;1197:9;1172:53;;;1162:63;1066:175;-1:-1;;;;1066:175;1248:394;;;1383:2;1371:9;1362:7;1358:23;1354:32;1351:2;;;1399:1;1396;1389:12;1351:2;1434:1;1451:53;1496:7;1476:9;1451:53;;;1441:63;;1413:97;1541:2;1559:67;1618:7;1609:6;1598:9;1594:22;1559:67;;;1549:77;;1520:112;1345:297;;;;;;1649:366;;;1770:2;1758:9;1749:7;1745:23;1741:32;1738:2;;;1786:1;1783;1776:12;1738:2;1821:1;1838:53;1883:7;1863:9;1838:53;;;1828:63;;1800:97;1928:2;1946:53;1991:7;1982:6;1971:9;1967:22;1946:53;;2022:257;;2134:2;2122:9;2113:7;2109:23;2105:32;2102:2;;;2150:1;2147;2140:12;2102:2;2185:1;2202:61;2255:7;2235:9;2202:61;;2286:269;;2404:2;2392:9;2383:7;2379:23;2375:32;2372:2;;;2420:1;2417;2410:12;2372:2;2455:1;2472:67;2531:7;2511:9;2472:67;;2562:533;;;;2710:2;2698:9;2689:7;2685:23;2681:32;2678:2;;;2726:1;2723;2716:12;2678:2;2761:1;2778:64;2834:7;2814:9;2778:64;;;2768:74;;2740:108;2879:2;2897:64;2953:7;2944:6;2933:9;2929:22;2897:64;;;2887:74;;2858:109;2998:2;3016:63;3071:7;3062:6;3051:9;3047:22;3016:63;;;3006:73;;2977:108;2672:423;;;;;;3102:241;;3206:2;3194:9;3185:7;3181:23;3177:32;3174:2;;;3222:1;3219;3212:12;3174:2;3257:1;3274:53;3319:7;3299:9;3274:53;;3350:263;;3465:2;3453:9;3444:7;3440:23;3436:32;3433:2;;;3481:1;3478;3471:12;3433:2;3516:1;3533:64;3589:7;3569:9;3533:64;;3620:142;3711:45;3750:5;3711:45;;;3706:3;3699:58;3693:69;;;3769:113;3852:24;3870:5;3852:24;;3889:152;3990:45;4010:24;4028:5;4010:24;;;3990:45;;4048:104;4125:21;4140:5;4125:21;;4159:148;4258:43;4277:23;4294:5;4277:23;;;4258:43;;4314:152;4415:45;4435:24;4453:5;4435:24;;4473:356;;4601:38;4633:5;4601:38;;;4651:88;4732:6;4727:3;4651:88;;;4644:95;;4744:52;4789:6;4784:3;4777:4;4770:5;4766:16;4744:52;;;4808:16;;;;;4581:248;-1:-1;;4581:248;4836:152;4932:50;4976:5;4932:50;;5317:144;5409:46;5449:5;5409:46;;5468:347;;5580:39;5613:5;5580:39;;;5631:71;5695:6;5690:3;5631:71;;;5624:78;;5707:52;5752:6;5747:3;5740:4;5733:5;5729:16;5707:52;;;5780:29;5802:6;5780:29;;;5771:39;;;;5560:255;-1:-1;;;5560:255;5823:327;;5983:67;6047:2;6042:3;5983:67;;;6083:29;6063:50;;6141:2;6132:12;;5969:181;-1:-1;;5969:181;6159:374;;6319:67;6383:2;6378:3;6319:67;;;6419:34;6399:55;;-1:-1;;;6483:2;6474:12;;6467:29;6524:2;6515:12;;6305:228;-1:-1;;6305:228;6542:400;;6720:85;6802:2;6797:3;6720:85;;;6838:66;6818:87;;6933:2;6924:12;;6706:236;-1:-1;;6706:236;6951:377;;7111:67;7175:2;7170:3;7111:67;;;7211:34;7191:55;;-1:-1;;;7275:2;7266:12;;7259:32;7319:2;7310:12;;7097:231;-1:-1;;7097:231;7337:398;;7515:84;7597:1;7592:3;7515:84;;;-1:-1;;;;;;7612:87;;7727:1;7718:11;;7501:234;-1:-1;;7501:234;7744:370;;7904:67;7968:2;7963:3;7904:67;;;8004:34;7984:55;;-1:-1;;;8068:2;8059:12;;8052:25;8105:2;8096:12;;7890:224;-1:-1;;7890:224;8123:374;;8283:67;8347:2;8342:3;8283:67;;;8383:34;8363:55;;-1:-1;;;8447:2;8438:12;;8431:29;8488:2;8479:12;;8269:228;-1:-1;;8269:228;8506:330;;8666:67;8730:2;8725:3;8666:67;;;8766:32;8746:53;;8827:2;8818:12;;8652:184;-1:-1;;8652:184;8844:113;8927:24;8945:5;8927:24;;8964:383;;9111:75;9182:3;9173:6;9111:75;;;9208:2;9203:3;9199:12;9192:19;;9222:75;9293:3;9284:6;9222:75;;;-1:-1;9319:2;9310:12;;9099:248;-1:-1;;9099:248;9354:244;;9473:75;9544:3;9535:6;9473:75;;;-1:-1;9570:2;9561:12;;9461:137;-1:-1;9461:137;9605:553;;9821:93;9910:3;9901:6;9821:93;;;9814:100;;9925:73;9994:3;9985:6;9925:73;;;10020:1;10015:3;10011:11;10004:18;;10040:93;10129:3;10120:6;10040:93;;;10033:100;9802:356;-1:-1;;;;;9802:356;10165:917;;10521:148;10665:3;10521:148;;;10514:155;;10680:75;10751:3;10742:6;10680:75;;;10777:2;10772:3;10768:12;10761:19;;10791:75;10862:3;10853:6;10791:75;;;10888:2;10883:3;10879:12;10872:19;;10909:148;11053:3;10909:148;;11089:213;11207:2;11192:18;;11221:71;11196:9;11265:6;11221:71;;11309:451;11491:2;11476:18;;11505:79;11480:9;11557:6;11505:79;;;11595:72;11663:2;11652:9;11648:18;11639:6;11595:72;;;11678;11746:2;11735:9;11731:18;11722:6;11678:72;;11767:340;11921:2;11906:18;;11935:79;11910:9;11987:6;11935:79;;;12025:72;12093:2;12082:9;12078:18;12069:6;12025:72;;12114:324;12260:2;12245:18;;12274:71;12249:9;12318:6;12274:71;;12445:201;12557:2;12542:18;;12571:65;12546:9;12609:6;12571:65;;12653:239;12784:2;12769:18;;12798:84;12773:9;12855:6;12798:84;;13395:231;13522:2;13507:18;;13536:80;13511:9;13589:6;13536:80;;13633:301;13771:2;13785:47;;;13756:18;;13846:78;13756:18;13910:6;13846:78;;13941:407;14132:2;14146:47;;;14117:18;;14207:131;14117:18;14207:131;;14355:407;14546:2;14560:47;;;14531:18;;14621:131;14531:18;14621:131;;14769:407;14960:2;14974:47;;;14945:18;;15035:131;14945:18;15035:131;;15183:407;15374:2;15388:47;;;15359:18;;15449:131;15359:18;15449:131;;15597:407;15788:2;15802:47;;;15773:18;;15863:131;15773:18;15863:131;;16011:407;16202:2;16216:47;;;16187:18;;16277:131;16187:18;16277:131;;16425:213;16543:2;16528:18;;16557:71;16532:9;16601:6;16557:71;;16645:324;16791:2;16776:18;;16805:71;16780:9;16849:6;16805:71;;16976:435;17150:2;17135:18;;17164:71;17139:9;17208:6;17164:71;;;17246:72;17314:2;17303:9;17299:18;17290:6;17246:72;;17418:121;17505:12;;17476:63;17829:163;17932:19;;;17981:4;17972:14;;17925:67;18154:91;;18216:24;18234:5;18216:24;;18252:85;18318:13;18311:21;;18294:43;18344:144;-1:-1;;;;;;18405:78;;18388:100;18495:72;18557:5;18540:27;18574:105;;18650:24;18668:5;18650:24;;18686:128;18759:5;18765:44;18759:5;18765:44;;18821:109;-1:-1;;;;;18883:42;;18866:64;18937:121;-1:-1;;;;;18999:54;;18982:76;19144:88;19216:10;19205:22;;19188:44;19239:129;;19326:37;19357:5;19326:37;;20227:128;;20315:35;20344:5;20315:35;;20606:268;20671:1;20678:101;20692:6;20689:1;20686:13;20678:101;;;20759:11;;;20753:18;20740:11;;;20733:39;20714:2;20707:10;20678:101;;;20794:6;20791:1;20788:13;20785:2;;;20859:1;20850:6;20845:3;20841:16;20834:27;20785:2;20655:219;;;;;20882:95;;20946:26;20966:5;21145:89;21209:20;21223:5;21209:20;;21241:97;21329:2;21309:14;-1:-1;;21305:28;;21289:49;21346:94;21420:2;21416:14;;21388:52;21448:102;21528:1;21521:5;21518:12;21508:2;;21534:9;21557:117;21626:24;21644:5;21626:24;;;21619:5;21616:35;21606:2;;21665:1;21662;21655:12;21681:111;21747:21;21762:5;21747:21;;21799:145;21882:38;21914:5;21882:38;;21951:117;22020:24;22038:5;22020:24;;22075:117;22144:24;22162:5;22144:24;;22199:115;22267:23;22284:5;22267:23;

bzzr://f00a104504795ab5e9ea5fb3b30245a3bd89162b17e4a78eb44812353c050c46