Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

pragma solidity 0.5.17;

import "./GAMER.sol";

contract GAMERDelegationStorage {
    /**
     * @notice Implementation address for this contract
     */
    address public implementation;
}

contract GAMERDelegatorInterface is GAMERDelegationStorage {
    /**
     * @notice Emitted when implementation is changed
     */
    event NewImplementation(address oldImplementation, address newImplementation);

    /**
     * @notice Called by the gov to update the implementation of the delegator
     * @param implementation_ The address of the new implementation for delegation
     * @param allowResign Flag to indicate whether to call _resignImplementation on the old implementation
     * @param becomeImplementationData The encoded bytes data to be passed to _becomeImplementation
     */
    function _setImplementation(address implementation_, bool allowResign, bytes memory becomeImplementationData) public;
}

contract GAMERDelegateInterface is GAMERDelegationStorage {
    /**
     * @notice Called by the delegator on a delegate to initialize it for duty
     * @dev Should revert if any issues arise which make it unfit for delegation
     * @param data The encoded bytes data for any initialization
     */
    function _becomeImplementation(bytes memory data) public;

    /**
     * @notice Called by the delegator on a delegate to forfeit its responsibility
     */
    function _resignImplementation() public;
}


contract GAMERDelegate is GAMER, GAMERDelegateInterface {
    /**
     * @notice Construct an empty delegate
     */
    constructor() public {}

    /**
     * @notice Called by the delegator on a delegate to initialize it for duty
     * @param data The encoded bytes data for any initialization
     */
    function _becomeImplementation(bytes memory data) public {
        // Shh -- currently unused
        data;

        // Shh -- we don't ever want this hook to be marked pure
        if (false) {
            implementation = address(0);
        }

        require(msg.sender == gov, "only the gov may call _becomeImplementation");
    }

    /**
     * @notice Called by the delegator on a delegate to forfeit its responsibility
     */
    function _resignImplementation() public {
        // Shh -- we don't ever want this hook to be marked pure
        if (false) {
            implementation = address(0);
        }

        require(msg.sender == gov, "only the gov may call _resignImplementation");
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.5.17;

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

pragma solidity 0.5.17;

/* import "./GAMERTokenInterface.sol"; */
import "./GAMERGovernance.sol";

contract GAMERToken is GAMERGovernanceToken {
    // Modifiers
    modifier onlyGov() {
        require(msg.sender == gov, 'not gov');
        _;
    }

    modifier onlyRebaser() {
        require(msg.sender == rebaser);
        _;
    }

    modifier onlyMinter() {
        require(msg.sender == rebaser || msg.sender == incentivizer || msg.sender == stakingPool || msg.sender == teamPool || msg.sender == dev || msg.sender == gov, "not minter");
        _;
    }

    modifier validRecipient(address to) {
        require(to != address(0x0));
        require(to != address(this));
        _;
    }

    function initialize(
        string memory name_,
        string memory symbol_,
        uint8 decimals_
    )
        public
    {
        require(gamersScalingFactor == 0, "already initialized");
        name = name_;
        symbol = symbol_;
        decimals = decimals_;
    }

    /**
    * @notice Computes the current totalSupply
    */
    function totalSupply()
        external
        view
        returns (uint256)
    {
        return _totalSupply.div(10**24/ (BASE));
    }
    
    /**
    * @notice Computes the current max scaling factor
    */
    function maxScalingFactor()
        external
        view
        returns (uint256)
    {
        return _maxScalingFactor();
    }

    function _maxScalingFactor()
        internal
        view
        returns (uint256)
    {
        // scaling factor can only go up to 2**256-1 = initSupply * gamersScalingFactor
        // this is used to check if gamersScalingFactor will be too high to compute balances when rebasing.
        return uint256(-1) / initSupply;
    }

    /**
    * @notice Mints new tokens, increasing totalSupply, initSupply, and a users balance.
    * @dev Limited to onlyMinter modifier
    */
    function mint(address to, uint256 amount)
        external
        onlyMinter
        returns (bool)
    {
        _mint(to, amount);
        return true;
    }

    function _mint(address to, uint256 amount)
        internal
    {
      // increase totalSupply
      _totalSupply = _totalSupply.add(amount.mul(10**24/ (BASE)));

      // get underlying value
      uint256 gamerValue = amount.mul(internalDecimals).div(gamersScalingFactor);

      // increase initSupply
      initSupply = initSupply.add(gamerValue);

      // make sure the mint didnt push maxScalingFactor too low
      require(gamersScalingFactor <= _maxScalingFactor(), "max scaling factor too low");

      // add balance
      _gamerBalances[to] = _gamerBalances[to].add(gamerValue);
      emit Transfer(address(0), to, amount);
    
      // add delegates to the minter
      _moveDelegates(address(0), _delegates[to], gamerValue);
      emit Mint(to, amount);
    }

    /* - ERC20 functionality - */

    /**
    * @dev Transfer tokens to a specified address.
    * @param to The address to transfer to.
    * @param value The amount to be transferred.
    * @return True on success, false otherwise.
    */
    function transfer(address to, uint256 value)
        external
        validRecipient(to)
        returns (bool)
    {
        // underlying balance is stored in gamers, so divide by current scaling factor

        // note, this means as scaling factor grows, dust will be untransferrable.
        // minimum transfer value == gamersScalingFactor / 1e24;

        // get amount in underlying
        uint256 gamerValue = value.mul(internalDecimals).div(gamersScalingFactor);

        // sub from balance of sender
        _gamerBalances[msg.sender] = _gamerBalances[msg.sender].sub(gamerValue);

        // add to balance of receiver
        _gamerBalances[to] = _gamerBalances[to].add(gamerValue);
        emit Transfer(msg.sender, to, value);

        _moveDelegates(_delegates[msg.sender], _delegates[to], gamerValue);
        return true;
    }

    /**
    * @dev Transfer tokens from one address to another.
    * @param from The address you want to send tokens from.
    * @param to The address you want to transfer to.
    * @param value The amount of tokens to be transferred.
    */
    function transferFrom(address from, address to, uint256 value)
        external
        validRecipient(to)
        returns (bool)
    {
        // decrease allowance
        _allowedFragments[from][msg.sender] = _allowedFragments[from][msg.sender].sub(value);

        // get value in gamers
        uint256 gamerValue = value.mul(internalDecimals).div(gamersScalingFactor);

        // sub from from
        _gamerBalances[from] = _gamerBalances[from].sub(gamerValue);
        _gamerBalances[to] = _gamerBalances[to].add(gamerValue);
        emit Transfer(from, to, value);

        _moveDelegates(_delegates[from], _delegates[to], gamerValue);
        return true;
    }

    /**
    * @param who The address to query.
    * @return The balance of the specified address.
    */
    function balanceOf(address who)
      external
      view
      returns (uint256)
    {
      return _gamerBalances[who].mul(gamersScalingFactor).div(internalDecimals);
    }

    /** @notice Currently returns the internal storage amount
    * @param who The address to query.
    * @return The underlying balance of the specified address.
    */
    function balanceOfUnderlying(address who)
      external
      view
      returns (uint256)
    {
      return _gamerBalances[who];
    }

    /**
     * @dev Function to check the amount of tokens that an owner has allowed to a spender.
     * @param owner_ The address which owns the funds.
     * @param spender The address which will spend the funds.
     * @return The number of tokens still available for the spender.
     */
    function allowance(address owner_, address spender)
        external
        view
        returns (uint256)
    {
        return _allowedFragments[owner_][spender];
    }

    /**
     * @dev Approve the passed address to spend the specified amount of tokens on behalf of
     * msg.sender. This method is included for ERC20 compatibility.
     * increaseAllowance and decreaseAllowance should be used instead.
     * Changing an allowance with this method brings the risk that someone may transfer both
     * the old and the new allowance - if they are both greater than zero - if a transfer
     * transaction is mined before the later approve() call is mined.
     *
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     */
    function approve(address spender, uint256 value)
        external
        returns (bool)
    {
        _allowedFragments[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev Increase the amount of tokens that an owner has allowed to a spender.
     * This method should be used instead of approve() to avoid the double approval vulnerability
     * described above.
     * @param spender The address which will spend the funds.
     * @param addedValue The amount of tokens to increase the allowance by.
     */
    function increaseAllowance(address spender, uint256 addedValue)
        external
        returns (bool)
    {
        _allowedFragments[msg.sender][spender] =
            _allowedFragments[msg.sender][spender].add(addedValue);
        emit Approval(msg.sender, spender, _allowedFragments[msg.sender][spender]);
        return true;
    }

    /**
     * @dev Decrease the amount of tokens that an owner has allowed to a spender.
     *
     * @param spender The address which will spend the funds.
     * @param subtractedValue The amount of tokens to decrease the allowance by.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue)
        external
        returns (bool)
    {
        uint256 oldValue = _allowedFragments[msg.sender][spender];
        if (subtractedValue >= oldValue) {
            _allowedFragments[msg.sender][spender] = 0;
        } else {
            _allowedFragments[msg.sender][spender] = oldValue.sub(subtractedValue);
        }
        emit Approval(msg.sender, spender, _allowedFragments[msg.sender][spender]);
        return true;
    }

    /* - Governance Functions - */

    /** @notice sets the rebaser
     * @param rebaser_ The address of the rebaser contract to use for authentication.
     */
    function _setRebaser(address rebaser_)
        external
        onlyGov
    {
        address oldRebaser = rebaser;
        rebaser = rebaser_;
        emit NewRebaser(oldRebaser, rebaser_);
    }

    /** @notice sets the incentivizer
     * @param incentivizer_ The address of the incentivizer contract to use for authentication.
     */
    function _setIncentivizer(address incentivizer_)
        external
        onlyGov
    {
        address oldIncentivizer = incentivizer;
        incentivizer = incentivizer_;
        emit NewIncentivizer(oldIncentivizer, incentivizer_);
    }

    /** @notice sets the stakingPool
     * @param stakingPool_ The address of the stakingPool contract to use for authentication.
     */
    function _setStakingPool(address stakingPool_)
        external
        onlyGov
    {
        address oldStakingPool = stakingPool;
        stakingPool = stakingPool_;
        emit NewStakingPool(oldStakingPool, stakingPool_);
    }

    /** @notice sets the teamPool
     * @param teamPool_ The address of the teamPool contract to use for authentication.
     */
    function _setTeamPool(address teamPool_)
        external
        onlyGov
    {
        address oldTeamPool = teamPool;
        teamPool = teamPool_;
        emit NewTeamPool(oldTeamPool, teamPool_);
    }

    /** @notice sets the dev
     * @param dev_ The address of the dev contract to use for authentication.
     */
    function _setDev(address dev_)
        external
        onlyGov
    {
        address oldDev = dev;
        dev = dev_;
        emit NewDev(oldDev, dev_);
    }

    /** @notice sets the pendingGov
     * @param pendingGov_ The address of the rebaser contract to use for authentication.
     */
    function _setPendingGov(address pendingGov_)
        external
        onlyGov
    {
        address oldPendingGov = pendingGov;
        pendingGov = pendingGov_;
        emit NewPendingGov(oldPendingGov, pendingGov_);
    }

    /** @notice lets msg.sender accept governance
     *
     */
    function _acceptGov()
        external
    {
        require(msg.sender == pendingGov, "!pending");
        address oldGov = gov;
        gov = pendingGov;
        pendingGov = address(0);
        emit NewGov(oldGov, gov);
    }

    /* - Extras - */

    /**
    * @notice Initiates a new rebase operation, provided the minimum time period has elapsed.
    *
    * @dev The supply adjustment equals (totalSupply * DeviationFromTargetRate) / rebaseLag
    *      Where DeviationFromTargetRate is (MarketOracleRate - targetRate) / targetRate
    *      and targetRate is CpiOracleRate / baseCpi
    */
    function rebase(
        uint256 epoch,
        uint256 indexDelta,
        bool positive
    )
        external
        onlyRebaser
        returns (uint256)
    {
        if (indexDelta == 0) {
          emit Rebase(epoch, gamersScalingFactor, gamersScalingFactor);
          return _totalSupply;
        }

        uint256 prevGrapsScalingFactor = gamersScalingFactor;

        if (!positive) {
           gamersScalingFactor = gamersScalingFactor.mul(BASE.sub(indexDelta)).div(BASE);
        } else {
            uint256 newScalingFactor = gamersScalingFactor.mul(BASE.add(indexDelta)).div(BASE);
            if (newScalingFactor < _maxScalingFactor()) {
                gamersScalingFactor = newScalingFactor;
            } else {
              gamersScalingFactor = _maxScalingFactor();
            }
        }

        _totalSupply = initSupply.mul(gamersScalingFactor).div(BASE);
        emit Rebase(epoch, prevGrapsScalingFactor, gamersScalingFactor);
        return _totalSupply;
    }
}

contract GAMER is GAMERToken {
    /**
     * @notice Initialize the new money market
     * @param name_ ERC-20 name of this token
     * @param symbol_ ERC-20 symbol of this token
     * @param decimals_ ERC-20 decimal precision of this token
     */
    function initialize(
        string memory name_,
        string memory symbol_,
        uint8 decimals_,
        address initial_owner,
        uint256 initSupply_
    )
        public
    {
        require(initSupply_ > 0, "0 init supply");

        super.initialize(name_, symbol_, decimals_);

        initSupply = initSupply_.mul(10**24/ (BASE));
        _totalSupply = initSupply;
        gamersScalingFactor = BASE;
        _gamerBalances[initial_owner] = initSupply_.mul(10**24 / (BASE));

        // owner renounces ownership after deployment as they need to set
        // rebaser and incentivizer
        // gov = gov_;
    }
}

pragma solidity 0.5.17;

import "./GAMERTokenInterface.sol";
import "./GAMERDelegate.sol";

contract GAMERDelegator is GAMERTokenInterface, GAMERDelegatorInterface {
    /**
     * @notice Construct a new GAMER
     * @param name_ ERC-20 name of this token
     * @param symbol_ ERC-20 symbol of this token
     * @param decimals_ ERC-20 decimal precision of this token
     * @param initSupply_ Initial token amount
     * @param implementation_ The address of the implementation the contract delegates to
     * @param becomeImplementationData The encoded args for becomeImplementation
     */
    constructor(
        string memory name_,
        string memory symbol_,
        uint8 decimals_,
        uint256 initSupply_,
        address implementation_,
        bytes memory becomeImplementationData
    )
        public
    {


        // Creator of the contract is gov during initialization
        gov = msg.sender;

        // First delegate gets to initialize the delegator (i.e. storage contract)
        delegateTo(
            implementation_,
            abi.encodeWithSignature(
                "initialize(string,string,uint8,address,uint256)",
                name_,
                symbol_,
                decimals_,
                msg.sender,
                initSupply_
            )
        );

        // New implementations always get set via the settor (post-initialize)
        _setImplementation(implementation_, false, becomeImplementationData);

    }

    /**
     * @notice Called by the gov to update the implementation of the delegator
     * @param implementation_ The address of the new implementation for delegation
     * @param allowResign Flag to indicate whether to call _resignImplementation on the old implementation
     * @param becomeImplementationData The encoded bytes data to be passed to _becomeImplementation
     */
    function _setImplementation(address implementation_, bool allowResign, bytes memory becomeImplementationData) public {
        require(msg.sender == gov, "GAMERDelegator::_setImplementation: Caller must be gov");

        if (allowResign) {
            delegateToImplementation(abi.encodeWithSignature("_resignImplementation()"));
        }

        address oldImplementation = implementation;
        implementation = implementation_;

        delegateToImplementation(abi.encodeWithSignature("_becomeImplementation(bytes)", becomeImplementationData));

        emit NewImplementation(oldImplementation, implementation);
    }

    /**
     * @notice Sender supplies assets into the market and receives cTokens in exchange
     * @dev Accrues interest whether or not the operation succeeds, unless reverted
     * @param mintAmount The amount of the underlying asset to supply
     * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
     */
    function mint(address to, uint256 mintAmount)
        external
        returns (bool)
    {
        to; mintAmount; // Shh
        delegateAndReturn();
    }

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

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

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

    /**
     * @dev Increase the amount of tokens that an owner has allowed to a spender.
     * This method should be used instead of approve() to avoid the double approval vulnerability
     * described above.
     * @param spender The address which will spend the funds.
     * @param addedValue The amount of tokens to increase the allowance by.
     */
    function increaseAllowance(
        address spender,
        uint256 addedValue
    )
        external
        returns (bool)
    {
        spender; addedValue; // Shh
        delegateAndReturn();
    }

    function totalSupply()
        external
        view
        returns (uint256)
    {
        delegateToViewAndReturn();
    }

    function maxScalingFactor()
        external
        view
        returns (uint256)
    {
        delegateToViewAndReturn();
    }

    function rebase(
        uint256 epoch,
        uint256 indexDelta,
        bool positive
    )
        external
        returns (uint256)
    {
        epoch; indexDelta; positive;
        delegateAndReturn();
    }

    /**
     * @dev Decrease the amount of tokens that an owner has allowed to a spender.
     *
     * @param spender The address which will spend the funds.
     * @param subtractedValue The amount of tokens to decrease the allowance by.
     */
    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    )
        external
        returns (bool)
    {
        spender; subtractedValue; // Shh
        delegateAndReturn();
    }

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

    /**
     * @notice Get the current allowance from `owner` for `spender`
     * @param delegator The address of the account which has designated a delegate
     * @return Address of delegatee
     */
    function delegates(
        address delegator
    )
        external
        view
        returns (address)
    {
        delegator; // Shh
        delegateToViewAndReturn();
    }

    /**
     * @notice Get the token balance of the `owner`
     * @param owner The address of the account to query
     * @return The number of tokens owned by `owner`
     */
    function balanceOf(address owner)
        external
        view
        returns (uint256)
    {
        owner; // Shh
        delegateToViewAndReturn();
    }

    /**
     * @notice Currently unused. For future compatability
     * @param owner The address of the account to query
     * @return The number of underlying tokens owned by `owner`
     */
    function balanceOfUnderlying(address owner)
        external
        view
        returns (uint256)
    {
        owner; // Shh
        delegateToViewAndReturn();
    }

    /*** Gov Functions ***/

    /**
      * @notice Begins transfer of gov rights. The newPendingGov must call `_acceptGov` to finalize the transfer.
      * @dev Gov function to begin change of gov. The newPendingGov must call `_acceptGov` to finalize the transfer.
      * @param newPendingGov New pending gov.
      */
    function _setPendingGov(address newPendingGov)
        external
    {
        newPendingGov; // Shh
        delegateAndReturn();
    }

    function _setRebaser(address rebaser_)
        external
    {
        rebaser_; // Shh
        delegateAndReturn();
    }

    function _setIncentivizer(address incentivizer_)
        external
    {
        incentivizer_; // Shh
        delegateAndReturn();
    }

    function _setStakingPool(address stakingPool_)
        external
    {
        stakingPool_; //Shh
        delegateAndReturn();
    }

    function _setTeamPool(address teamPool_)
        external
    {
        teamPool_; //Shh
        delegateAndReturn();
    }

    function _setDev(address dev_)
        external
    {
        dev_; //Shh
        delegateAndReturn();
    }

    /**
      * @notice Accepts transfer of gov rights. msg.sender must be pendingGov
      * @dev Gov function for pending gov to accept role and update gov
      * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
      */
    function _acceptGov()
        external
    {
        delegateAndReturn();
    }


    function getPriorVotes(address account, uint blockNumber)
        external
        view
        returns (uint256)
    {
        account; blockNumber;
        delegateToViewAndReturn();
    }

    function delegateBySig(
        address delegatee,
        uint nonce,
        uint expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
        external
    {
        delegatee; nonce; expiry; v; r; s;
        delegateAndReturn();
    }

    function delegate(address delegatee)
        external
    {
        delegatee;
        delegateAndReturn();
    }

    function getCurrentVotes(address account)
        external
        view
        returns (uint256)
    {
        account;
        delegateToViewAndReturn();
    }

    /**
     * @notice Internal method to delegate execution to another contract
     * @dev It returns to the external caller whatever the implementation returns or forwards reverts
     * @param callee The contract to delegatecall
     * @param data The raw data to delegatecall
     * @return The returned bytes from the delegatecall
     */
    function delegateTo(address callee, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returnData) = callee.delegatecall(data);
        assembly {
            if eq(success, 0) {
                revert(add(returnData, 0x20), returndatasize)
            }
        }
        return returnData;
    }

    /**
     * @notice Delegates execution to the implementation contract
     * @dev It returns to the external caller whatever the implementation returns or forwards reverts
     * @param data The raw data to delegatecall
     * @return The returned bytes from the delegatecall
     */
    function delegateToImplementation(bytes memory data) public returns (bytes memory) {
        return delegateTo(implementation, data);
    }

    /**
     * @notice Delegates execution to an implementation contract
     * @dev It returns to the external caller whatever the implementation returns or forwards reverts
     *  There are an additional 2 prefix uints from the wrapper returndata, which we ignore since we make an extra hop.
     * @param data The raw data to delegatecall
     * @return The returned bytes from the delegatecall
     */
    function delegateToViewImplementation(bytes memory data) public view returns (bytes memory) {
        (bool success, bytes memory returnData) = address(this).staticcall(abi.encodeWithSignature("delegateToImplementation(bytes)", data));
        assembly {
            if eq(success, 0) {
                revert(add(returnData, 0x20), returndatasize)
            }
        }
        return abi.decode(returnData, (bytes));
    }

    function delegateToViewAndReturn() private view returns (bytes memory) {
        (bool success, ) = address(this).staticcall(abi.encodeWithSignature("delegateToImplementation(bytes)", msg.data));

        assembly {
            let free_mem_ptr := mload(0x40)
            returndatacopy(free_mem_ptr, 0, returndatasize)

            switch success
            case 0 { revert(free_mem_ptr, returndatasize) }
            default { return(add(free_mem_ptr, 0x40), returndatasize) }
        }
    }

    function delegateAndReturn() private returns (bytes memory) {
        (bool success, ) = implementation.delegatecall(msg.data);

        assembly {
            let free_mem_ptr := mload(0x40)
            returndatacopy(free_mem_ptr, 0, returndatasize)

            switch success
            case 0 { revert(free_mem_ptr, returndatasize) }
            default { return(free_mem_ptr, returndatasize) }
        }
    }

    /**
     * @notice Delegates execution to an implementation contract
     * @dev It returns to the external caller whatever the implementation returns or forwards reverts
     */
    function () external payable {
        require(msg.value == 0,"GAMERDelegator:fallback: cannot send value to fallback");

        // delegate all other functions to current implementation
        delegateAndReturn();
    }
}

pragma solidity 0.5.17;
pragma experimental ABIEncoderV2;

import "./GAMERGovernanceStorage.sol";
import "./GAMERTokenInterface.sol";

contract GAMERGovernanceToken is GAMERTokenInterface {

      /// @notice An event thats emitted when an account changes its delegate
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /// @notice An event thats emitted when a delegate account's vote balance changes
    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

    /**
     * @notice Delegate votes from `msg.sender` to `delegatee`
     * @param delegator The address to get delegatee for
     */
    function delegates(address delegator)
        external
        view
        returns (address)
    {
        return _delegates[delegator];
    }

   /**
    * @notice Delegate votes from `msg.sender` to `delegatee`
    * @param delegatee The address to delegate votes to
    */
    function delegate(address delegatee) external {
        return _delegate(msg.sender, delegatee);
    }

    /**
     * @notice Delegates votes from signatory to `delegatee`
     * @param delegatee The address to delegate votes to
     * @param nonce The contract state required to match the signature
     * @param expiry The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function delegateBySig(
        address delegatee,
        uint nonce,
        uint expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
        external
    {
        bytes32 domainSeparator = keccak256(
            abi.encode(
                DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                getChainId(),
                address(this)
            )
        );

        bytes32 structHash = keccak256(
            abi.encode(
                DELEGATION_TYPEHASH,
                delegatee,
                nonce,
                expiry
            )
        );

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                domainSeparator,
                structHash
            )
        );

        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "GAMER::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "GAMER::delegateBySig: invalid nonce");
        require(now <= expiry, "GAMER::delegateBySig: signature expired");
        return _delegate(signatory, delegatee);
    }

    /**
     * @notice Gets the current votes balance for `account`
     * @param account The address to get votes balance
     * @return The number of current votes for `account`
     */
    function getCurrentVotes(address account)
        external
        view
        returns (uint256)
    {
        uint32 nCheckpoints = numCheckpoints[account];
        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
    }

    /**
     * @notice Determine the prior number of votes for an account as of a block number
     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
     * @param account The address of the account to check
     * @param blockNumber The block number to get the vote balance at
     * @return The number of votes the account had as of the given block
     */
    function getPriorVotes(address account, uint blockNumber)
        external
        view
        returns (uint256)
    {
        require(blockNumber < block.number, "GAMER::getPriorVotes: not yet determined");

        uint32 nCheckpoints = numCheckpoints[account];
        if (nCheckpoints == 0) {
            return 0;
        }

        // First check most recent balance
        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
            return checkpoints[account][nCheckpoints - 1].votes;
        }

        // Next check implicit zero balance
        if (checkpoints[account][0].fromBlock > blockNumber) {
            return 0;
        }

        uint32 lower = 0;
        uint32 upper = nCheckpoints - 1;
        while (upper > lower) {
            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
            Checkpoint memory cp = checkpoints[account][center];
            if (cp.fromBlock == blockNumber) {
                return cp.votes;
            } else if (cp.fromBlock < blockNumber) {
                lower = center;
            } else {
                upper = center - 1;
            }
        }
        return checkpoints[account][lower].votes;
    }

    function _delegate(address delegator, address delegatee)
        internal
    {
        address currentDelegate = _delegates[delegator];
        uint256 delegatorBalance = _gamerBalances[delegator]; // balance of underlying GAMERs (not scaled);
        _delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
    }

    function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
        if (srcRep != dstRep && amount > 0) {
            if (srcRep != address(0)) {
                // decrease old representative
                uint32 srcRepNum = numCheckpoints[srcRep];
                uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
                uint256 srcRepNew = srcRepOld.sub(amount);
                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
            }

            if (dstRep != address(0)) {
                // increase new representative
                uint32 dstRepNum = numCheckpoints[dstRep];
                uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
                uint256 dstRepNew = dstRepOld.add(amount);
                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
            }
        }
    }

    function _writeCheckpoint(
        address delegatee,
        uint32 nCheckpoints,
        uint256 oldVotes,
        uint256 newVotes
    )
        internal
    {
        uint32 blockNumber = safe32(block.number, "GAMER::_writeCheckpoint: block number exceeds 32 bits");

        if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
            checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
        } else {
            checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
            numCheckpoints[delegatee] = nCheckpoints + 1;
        }

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

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

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}

pragma solidity 0.5.17;
pragma experimental ABIEncoderV2;

contract GAMERGovernanceStorage {
    /// @notice A record of each accounts delegate
    mapping (address => address) internal _delegates;

    /// @notice A checkpoint for marking number of votes from a given block
    struct Checkpoint {
        uint32 fromBlock;
        uint256 votes;
    }

    /// @notice A record of votes checkpoints for each account, by index
    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;

    /// @notice The number of checkpoints for each account
    mapping (address => uint32) public numCheckpoints;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    /// @notice The EIP-712 typehash for the delegation struct used by the contract
    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

    /// @notice A record of states for signing / validating signatures
    mapping (address => uint) public nonces;
}

pragma solidity 0.5.17;

import "./GAMERTokenStorage.sol";
import "./GAMERGovernanceStorage.sol";

contract GAMERTokenInterface is GAMERTokenStorage, GAMERGovernanceStorage {

    /// @notice An event thats emitted when an account changes its delegate
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /// @notice An event thats emitted when a delegate account's vote balance changes
    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

    /**
     * @notice Event emitted when tokens are rebased
     */
    event Rebase(uint256 epoch, uint256 prevGrapsScalingFactor, uint256 newGrapsScalingFactor);

    /*** Gov Events ***/

    /**
     * @notice Event emitted when pendingGov is changed
     */
    event NewPendingGov(address oldPendingGov, address newPendingGov);

    /**
     * @notice Event emitted when gov is changed
     */
    event NewGov(address oldGov, address newGov);

    /**
     * @notice Sets the rebaser contract
     */
    event NewRebaser(address oldRebaser, address newRebaser);

    /**
     * @notice Sets the incentivizer contract
     */
    event NewIncentivizer(address oldIncentivizer, address newIncentivizer);

    /**
     * @notice Sets the StakingPool contract
     */
    event NewStakingPool(address oldStakingPool, address newStakingPool);

    /**
     * @notice Sets the TeamPool contract
     */
    event NewTeamPool(address oldTeamPool, address newTeamPool);

    /**
     * @notice Sets the Dev contract
     */
    event NewDev(address oldDev, address newDev);

    /* - ERC20 Events - */

    /**
     * @notice EIP20 Transfer event
     */
    event Transfer(address indexed from, address indexed to, uint amount);

    /**
     * @notice EIP20 Approval event
     */
    event Approval(address indexed owner, address indexed spender, uint amount);

    /* - Extra Events - */
    /**
     * @notice Tokens minted event
     */
    event Mint(address to, uint256 amount);

    // Public functions
    function totalSupply() external view returns (uint256);
    function transfer(address to, uint256 value) external returns(bool);
    function transferFrom(address from, address to, uint256 value) external returns(bool);
    function balanceOf(address who) external view returns(uint256);
    function balanceOfUnderlying(address who) external view returns(uint256);
    function allowance(address owner_, address spender) external view returns(uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
    function maxScalingFactor() external view returns (uint256);

    /* - Governance Functions - */
    function getPriorVotes(address account, uint blockNumber) external view returns (uint256);
    function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) external;
    function delegate(address delegatee) external;
    function delegates(address delegator) external view returns (address);
    function getCurrentVotes(address account) external view returns (uint256);

    /* - Permissioned/Governance functions - */
    function mint(address to, uint256 amount) external returns (bool);
    function rebase(uint256 epoch, uint256 indexDelta, bool positive) external returns (uint256);
    function _setRebaser(address rebaser_) external;
    function _setIncentivizer(address incentivizer_) external;
    function _setPendingGov(address pendingGov_) external;
    function _acceptGov() external;
}

pragma solidity 0.5.17;

import "../lib/SafeMath.sol";

// Storage for a GAMER token
contract GAMERTokenStorage {

    using SafeMath for uint256;

    /**
     * @dev Guard variable for re-entrancy checks. Not currently used
     */
    bool internal _notEntered;

    /**
     * @notice EIP-20 token name for this token
     */
    string public name;

    /**
     * @notice EIP-20 token symbol for this token
     */
    string public symbol;

    /**
     * @notice EIP-20 token decimals for this token
     */
    uint8 public decimals;

    /**
     * @notice Governor for this contract
     */
    address public gov;

    /**
     * @notice Pending governance for this contract
     */
    address public pendingGov;

    /**
     * @notice Approved rebaser for this contract
     */
    address public rebaser;

    /**
     * @notice Reserve address of GAMER protocol
     */
    address public incentivizer;

    /**
     * @notice stakingPool address of GAMER protocol
     */
    address public stakingPool;

    /**
     * @notice teamPool address of GAMER protocol
     */
    address public teamPool;

    /**
     * @notice dev address of GAMER protocol
     */
    address public dev;

    /**
     * @notice Total supply of GAMERs
     */
    uint256 internal _totalSupply;

    /**
     * @notice Internal decimals used to handle scaling factor
     */
    uint256 public constant internalDecimals = 10**24;

    /**
     * @notice Used for percentage maths
     */
    uint256 public constant BASE = 10**18;

    /**
     * @notice Scaling factor that adjusts everyone's balances
     */
    uint256 public gamersScalingFactor;

    mapping (address => uint256) internal _gamerBalances;

    mapping (address => mapping (address => uint256)) internal _allowedFragments;

    uint256 public initSupply;

}

{
  "evmVersion": "istanbul",
  "optimizer": {
    "enabled": true,
    "runs": 50000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldDev","type":"address"},{"indexed":false,"internalType":"address","name":"newDev","type":"address"}],"name":"NewDev","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldGov","type":"address"},{"indexed":false,"internalType":"address","name":"newGov","type":"address"}],"name":"NewGov","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldIncentivizer","type":"address"},{"indexed":false,"internalType":"address","name":"newIncentivizer","type":"address"}],"name":"NewIncentivizer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldPendingGov","type":"address"},{"indexed":false,"internalType":"address","name":"newPendingGov","type":"address"}],"name":"NewPendingGov","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldRebaser","type":"address"},{"indexed":false,"internalType":"address","name":"newRebaser","type":"address"}],"name":"NewRebaser","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldStakingPool","type":"address"},{"indexed":false,"internalType":"address","name":"newStakingPool","type":"address"}],"name":"NewStakingPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldTeamPool","type":"address"},{"indexed":false,"internalType":"address","name":"newTeamPool","type":"address"}],"name":"NewTeamPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"epoch","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"prevGrapsScalingFactor","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newGrapsScalingFactor","type":"uint256"}],"name":"Rebase","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"constant":true,"inputs":[],"name":"BASE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"DELEGATION_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"_acceptGov","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"name":"_becomeImplementation","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"_resignImplementation","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"dev_","type":"address"}],"name":"_setDev","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"incentivizer_","type":"address"}],"name":"_setIncentivizer","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"pendingGov_","type":"address"}],"name":"_setPendingGov","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"rebaser_","type":"address"}],"name":"_setRebaser","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"stakingPool_","type":"address"}],"name":"_setStakingPool","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"teamPool_","type":"address"}],"name":"_setTeamPool","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"owner_","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"who","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"who","type":"address"}],"name":"balanceOfUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint32","name":"","type":"uint32"}],"name":"checkpoints","outputs":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint256","name":"votes","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"delegator","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"dev","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"gamersScalingFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getCurrentVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPriorVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"gov","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"incentivizer","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"initSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint8","name":"decimals_","type":"uint8"}],"name":"initialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint8","name":"decimals_","type":"uint8"},{"internalType":"address","name":"initial_owner","type":"address"},{"internalType":"uint256","name":"initSupply_","type":"uint256"}],"name":"initialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"internalDecimals","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"maxScalingFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"pendingGov","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"epoch","type":"uint256"},{"internalType":"uint256","name":"indexDelta","type":"uint256"},{"internalType":"bool","name":"positive","type":"bool"}],"name":"rebase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"rebaser","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"stakingPool","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"teamPool","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

1429:1020:2:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1429:1020:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;334:18:7;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;334:18:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6550:228:1;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;6550:228:1;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;994:26:7;;;:::i;:::-;;;;;;;;;;;;;;;;;;;1273:131:1;;;:::i;:::-;;;;;;;;;;;;;;;;797:22:7;;;:::i;606:18::-;;;:::i;2179:268:2:-;;;:::i;:::-;;706:281:1;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;706:281:1;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;706:281:1;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;706:281:1;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;706:281:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;706:281:1;;;;;;;;-1:-1:-1;706:281:1;;-1:-1:-1;;21:11;5:28;;2:2;;;46:1;43;36:12;2:2;706:281:1;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;706:281:1;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;706:281:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;706:281:1;;-1:-1:-1;;;706:281:1;;;;;-1:-1:-1;706:281:1;;-1:-1:-1;706:281:1:i;1055:139::-;;;:::i;9828:160::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;9828:160:1;;;;:::i;687:122:5:-;;;:::i;4180:672:1:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4180:672:1;;;;;;;;;;;;;;;;;;:::i;699:25:7:-;;;:::i;9134:232:1:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;9134:232:1;;;;:::i;520:21:7:-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;7142:337:1;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7142:337:1;;;;;;;;;:::i;1093:23:7:-;;;:::i;5315:137:1:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;5315:137:1;;;;:::i;1895:160::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;1895:160:1;;;;;;;;;:::i;10421:228::-;;;:::i;1739:335:2:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;1739:335:2;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;1739:335:2;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;1739:335:2;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;1739:335:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;1739:335:2;;-1:-1:-1;1739:335:2;;-1:-1:-1;;;;;1739:335:2:i;706:143:4:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;706:143:4;;;;:::i;987:102::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;987:102:4;;;;:::i;158:29:2:-;;;:::i;1378:49:7:-;;;:::i;12282:636:1:-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;12282:636:1;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;12282:636:1;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;12282:636:1;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;12282:636:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;12282:636:1;;;;;;;;-1:-1:-1;12282:636:1;;-1:-1:-1;;21:11;5:28;;2:2;;;46:1;43;36:12;2:2;12282:636:1;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;12282:636:1;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;12282:636:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;12282:636:1;;-1:-1:-1;;;12282:636:1;;;;;-1:-1:-1;;12282:636:1;;;;;;;;;;;:::i;891:27:7:-;;;:::i;568:49:5:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;568:49:5;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;4964:174:1;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4964:174:1;;;;:::i;10127:223::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;10127:223:1;;;;:::i;3514:1218:4:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3514:1218:4;;;;;;;;;:::i;11026:995:1:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;11026:995:1;;;;;;;;;;;;;;:::i;1095:39:5:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;1095:39:5;;;;:::i;1184:18:7:-;;;:::i;425:20::-;;;:::i;1797:25::-;;;:::i;8748:241:1:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;8748:241:1;;;;:::i;7733:502::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7733:502:1;;;;;;;;;:::i;3084:847::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3084:847:1;;;;;;;;;:::i;2844:248:4:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2844:248:4;;;;:::i;1512:1138::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;1512:1138:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;5751:170:1:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;5751:170:1;;;;;;;;;;;:::i;1614:34:7:-;;;:::i;900:117:5:-;;;:::i;1491:37:7:-;;;:::i;432:70:5:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;432:70:5;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;8404:196:1;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;8404:196:1;;;;:::i;9502:205::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;9502:205:1;;;;:::i;334:18:7:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;6550:228:1:-;6671:10;6633:4;6653:29;;;:17;:29;;;;;;;;;:38;;;;;;;;;;;:46;;;6714:36;;;;;;;6633:4;;6653:38;;6671:10;;6714:36;;;;;;;;-1:-1:-1;6767:4:1;6550:228;;;;;:::o;994:26:7:-;;;;;;:::o;1273:131:1:-;1348:7;1378:19;:17;:19::i;:::-;1371:26;;1273:131;;:::o;797:22:7:-;;;;;;:::o;606:18::-;;;;;;;;;:::o;2179:268:2:-;2389:3;;;;;;;2375:10;:17;2367:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2179:268::o;706:281:1:-;854:19;;:24;846:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;912:12;;;;:4;;:12;;;;;:::i;:::-;-1:-1:-1;934:16:1;;;;:6;;:16;;;;;:::i;:::-;-1:-1:-1;960:8:1;:20;;;;;;;;;;;;;;;-1:-1:-1;;706:281:1:o;1055:139::-;1155:12;;1125:7;;1155:32;;1172:14;1155:16;:32::i;9828:160::-;218:3;;;;;;;204:10;:17;196:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9923:3;;;;9936:10;;;;;;;;;;;9961:20;;;9923:3;;;;9961:20;;;;;;;;;;;;;;;;;;;;;;;243:1;9828:160;:::o;687:122:5:-;729:80;;;;;;;;;;;;;;;;;;687:122;:::o;4180:672:1:-;4304:4;4283:2;625:18;;;617:27;;;;;;662:19;;;676:4;662:19;;654:28;;;;;;4392:23;;;;;;;:17;:23;;;;;;;;4416:10;4392:35;;;;;;;;:46;;4432:5;4392:46;:39;:46;:::i;:::-;4354:23;;;;;;;:17;:23;;;;;;;;4378:10;4354:35;;;;;;;:84;;;;4533:19;;4501:52;;:27;:5;1421:6:7;4501:27:1;:9;:27;:::i;:::-;:31;:52;:31;:52;:::i;:::-;4612:20;;;;;;;:14;:20;;;;;;4480:73;;-1:-1:-1;4612:36:1;;4480:73;4612:36;:24;:36;:::i;:::-;4589:20;;;;;;;;:14;:20;;;;;;:59;;;;4679:18;;;;;;;:34;;4702:10;4679:34;:22;:34;:::i;:::-;4658:18;;;;;;;;:14;:18;;;;;;;;;:55;;;;4728:25;;;;;;;4658:18;;4728:25;;;;;;;;;;;;;4779:16;;;;;;;;:10;:16;;;;;;;4797:14;;;;;;;;4764:60;;4779:16;;;;4797:14;4813:10;4764:14;:60::i;:::-;-1:-1:-1;4841:4:1;;4180:672;-1:-1:-1;;;;;4180:672:1:o;699:25:7:-;;;;;;:::o;9134:232:1:-;218:3;;;;;;;204:10;:17;196:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9253:11;;;;9274:26;;;;;;;;;;;9315:44;;;9253:11;;;;9315:44;;;;;;;;;;;;;;;;;;;;;;;243:1;9134:232;:::o;520:21:7:-;;;;;;:::o;7142:337:1:-;7331:10;7240:4;7313:29;;;:17;:29;;;;;;;;;:38;;;;;;;;;;:54;;7356:10;7313:54;:42;:54;:::i;:::-;7278:10;7260:29;;;;:17;:29;;;;;;;;;:38;;;;;;;;;;;;:107;;;7382:69;;;;;;7260:38;;7382:69;;;;;;;;;;;-1:-1:-1;7468:4:1;7142:337;;;;:::o;1093:23:7:-;;;;;;:::o;5315:137:1:-;5426:19;;5398:7;5426:19;;;:14;:19;;;;;;;5315:137::o;1895:160::-;398:7;;1990:4;;398:7;;384:10;:21;;:51;;-1:-1:-1;423:12:1;;;;409:10;:26;384:51;:80;;;-1:-1:-1;453:11:1;;;;439:10;:25;384:80;:106;;;-1:-1:-1;482:8:1;;;;468:10;:22;384:106;:127;;;-1:-1:-1;508:3:1;;;;494:10;:17;384:127;:148;;;-1:-1:-1;529:3:1;;;;;;;515:10;:17;384:148;376:171;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2010:17;2016:2;2020:6;2010:5;:17::i;:::-;-1:-1:-1;2044:4:1;1895:160;;;;:::o;10421:228::-;10496:10;;;;10482;:24;10474:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10546:3;;;10565:10;;;10546:3;10565:10;;;10546:3;10559:16;;;;;;;;;;;10585:23;;;;;;;10623:19;;;10546:3;;;;;;10623:19;;;10638:3;;;;;;;10623:19;;;;;;10546:3;;10623:19;;;;;;;;10421:228;:::o;1739:335:2:-;2016:3;;;;;;;2002:10;:17;1994:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1739:335;:::o;706:143:4:-;821:21;;;;791:7;821:21;;;:10;:21;;;;;;;;706:143::o;987:102::-;1050:32;1060:10;1072:9;1050;:32::i;158:29:2:-;;;;;;:::o;1378:49:7:-;1421:6;1378:49;:::o;12282:636:1:-;12504:1;12490:11;:15;12482:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12534:43;12551:5;12558:7;12567:9;12534:16;:43::i;:::-;12601:31;1522:6:7;12617::1;:14;12601:11;;12617:14;;12601:31;:15;:31;:::i;:::-;12588:10;:44;;;12642:12;:25;1522:6:7;12677:19:1;:26;;;12745:32;;12761:6;:15;;12745:32;12713:29;;;;;;;;:14;:29;;;;;:64;;;;-1:-1:-1;;;;12282:636:1:o;891:27:7:-;;;;;;:::o;568:49:5:-;;;;;;;;;;;;;;;:::o;4964:174:1:-;5089:19;;5065;;;5037:7;5065:19;;;:14;:19;;;;;;5037:7;;5065:66;;1421:6:7;;5065:44:1;;:19;:44;:23;:44;:::i;10127:223::-;218:3;;;;;;;204:10;:17;196:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10243:10;;;;10263:24;;;;;;;;;;;10302:41;;;10243:10;;;;10302:41;;;;;;;;;;;;;;;;;;;;;;;243:1;10127:223;:::o;3514:1218:4:-;3619:7;3664:12;3650:11;:26;3642:79;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3754:23;;;3732:19;3754:23;;;:14;:23;;;;;;;;3791:17;3787:56;;3831:1;3824:8;;;;;3787:56;3900:20;;;;;;;:11;:20;;;;;;;;:38;3921:16;;;3900:38;;;;;;;;;:48;;:63;-1:-1:-1;3896:145:4;;3986:20;;;;;;;:11;:20;;;;;;;;4007:16;;;;;3986:38;;;;;;;;4022:1;3986:44;;;-1:-1:-1;3979:51:4;;3896:145;4099:20;;;;;;;:11;:20;;;;;;;;:23;;;;;;;;:33;:23;:33;:47;-1:-1:-1;4095:86:4;;;4169:1;4162:8;;;;;4095:86;4191:12;4232:16;;;4258:418;4273:5;4265:13;;:5;:13;;;4258:418;;;4336:1;4319:13;;;4318:19;;;4310:27;;4378:20;;:::i;:::-;-1:-1:-1;4401:20:4;;;;;;;:11;:20;;;;;;;;:28;;;;;;;;;;;;;4378:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4447:27;;4443:223;;;4501:8;;;;-1:-1:-1;4494:15:4;;-1:-1:-1;;;;4494:15:4;4443:223;4534:12;;:26;;;-1:-1:-1;4530:136:4;;;4588:6;4580:14;;4530:136;;;4650:1;4641:6;:10;4633:18;;4530:136;4258:418;;;;;-1:-1:-1;4692:20:4;;;;;;;:11;:20;;;;;;;;:27;;;;;;;;;;:33;;;;-1:-1:-1;;3514:1218:4;;;;:::o;11026:995:1:-;312:7;;11176;;312;;298:10;:21;290:30;;;;;;11203:15;11199:135;;11251:19;;11237:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11311:12:1;;11304:19;;11199:135;11377:19;;11412:8;11407:435;;11457:55;1522:6:7;11457:45:1;11481:20;1522:6:7;11490:10:1;11481:20;:8;:20;:::i;:::-;11457:19;;;:45;:23;:45;:::i;:55::-;11435:19;:77;11407:435;;;11543:24;11570:55;1522:6:7;11570:45:1;11594:20;1522:6:7;11603:10:1;11594:20;:8;:20;:::i;11570:55::-;11543:82;;11662:19;:17;:19::i;:::-;11643:16;:38;11639:193;;;11701:19;:38;;;11639:193;;;11798:19;:17;:19::i;:::-;11776;:41;11639:193;11407:435;;11867:45;1522:6:7;11867:35:1;11882:19;;11867:10;;:14;;:35;;;;:::i;:45::-;11852:12;:60;11965:19;;11927:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;12002:12:1;;330:1;11026:995;;;;;:::o;1095:39:5:-;;;;;;;;;;;;;:::o;1184:18:7:-;;;;;;:::o;425:20::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1797:25;;;;:::o;8748:241:1:-;218:3;;;;;;;204:10;:17;196:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8870:12;;;;8892:28;;;;;;;;;;;8935:47;;;8870:12;;;;8935:47;;;;;;;;;;;;;;;;;;;;;;;243:1;8748:241;:::o;7733:502::-;7893:10;7836:4;7875:29;;;:17;:29;;;;;;;;;:38;;;;;;;;;;7927:27;;;7923:201;;7988:10;8011:1;7970:29;;;:17;:29;;;;;;;;;:38;;;;;;;;;:42;7923:201;;;8084:29;:8;8097:15;8084:29;:12;:29;:::i;:::-;8061:10;8043:29;;;;:17;:29;;;;;;;;;:38;;;;;;;;;:70;7923:201;8147:10;8168:29;;;;:17;:29;;;;;;;;8138:69;;;8168:38;;;;;;;;;;;8138:69;;;;;;;;;8147:10;8138:69;;;;;;;;;;;-1:-1:-1;8224:4:1;;7733:502;-1:-1:-1;;;7733:502:1:o;3084:847::-;3190:4;3169:2;625:18;;;617:27;;;;;;662:19;;;676:4;662:19;;654:28;;;;;;3536:19;;3483:18;;3504:52;;:27;:5;1421:6:7;3504:27:1;:9;:27;:::i;:52::-;3649:10;3634:26;;;;:14;:26;;;;;;3483:73;;-1:-1:-1;3634:42:1;;3483:73;3634:42;:30;:42;:::i;:::-;3620:10;3605:26;;;;:14;:26;;;;;;:71;;;;:26;3746:18;;;;;;:34;;3769:10;3746:34;:22;:34;:::i;:::-;3725:18;;;;;;;:14;:18;;;;;;;;;:55;;;;3795:31;;;;;;;3725:18;;3804:10;;3795:31;;;;;;;;;;3863:10;3852:22;;;;:10;:22;;;;;;;;3876:14;;;;;;;;;;3837:66;;3852:22;;;3876:14;3892:10;3837:14;:66::i;:::-;-1:-1:-1;3920:4:1;;3084:847;-1:-1:-1;;;;3084:847:1:o;2844:248:4:-;2978:23;;;2933:7;2978:23;;;:14;:23;;;;;;;;3018:16;:67;;3084:1;3018:67;;;3037:20;;;;;;;:11;:20;;;;;;;;:38;3058:16;;;3037:38;;;;;;;;3073:1;3037:44;;3011:74;2844:248;-1:-1:-1;;;2844:248:4:o;1512:1138::-;1695:23;729:80:5;;;;;;;;;;;;;;;;;;;1821:4:4;1805:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1845:12;:10;:12::i;:::-;1883:4;1744:158;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;1744:158:4;;;1721:191;;;;;;1695:217;;1923:18;946:71:5;;;;;;;;;;;;;;;;;;;1967:135:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;1967:135:4;;;;;1944:168;;;;;;2163:119;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;2163:119:4;;;;;;2140:152;;;;;;;;;-1:-1:-1;2323:26:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1944:168;;-1:-1:-1;2140:152:4;;-1:-1:-1;;;2323:26:4;;;;;;;1967:135;-1:-1:-1;2323:26:4;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;2323:26:4;;;;;;-1:-1:-1;;2367:23:4;;;2359:75;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2461:17;;;;;;;:6;:17;;;;;:19;;;;;;;;2452:28;;2444:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2545:6;2538:3;:13;;2530:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2612:31;2622:9;2633;2612;:31::i;:::-;2605:38;;;;1512:1138;;;;;;;:::o;5751:170:1:-;5880:25;;;;5850:7;5880:25;;;:17;:25;;;;;;;;:34;;;;;;;;;;;;;5751:170::o;1614:34:7:-;;;;:::o;900:117:5:-;946:71;;;;;;;;;;;;;;;;;;900:117;:::o;1491:37:7:-;1522:6;1491:37;:::o;432:70:5:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;8404:196:1:-;218:3;;;;;;;204:10;:17;196:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8511:7;;;;8528:18;;;;;;;;;;;8561:32;;;8511:7;;;;8561:32;;;;;;;;;;;;;;;;;;;;;;;243:1;8404:196;:::o;9502:205::-;218:3;;;;;;;204:10;:17;196:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9612:8;;;;9630:20;;;;;;;;;;;9665:35;;;9612:8;;;;9665:35;;;;;;;;;;;;;;;;;;;;;;;243:1;9502:205;:::o;1410:333::-;1486:7;1726:10;;1720:2;1712:24;;;;;;1705:31;;1410:333;:::o;3102:130:0:-;3160:7;3186:39;3190:1;3193;3186:39;;;;;;;;;;;;;;;;;:3;:39::i;1322:134::-;1380:7;1406:43;1410:1;1413;1406:43;;;;;;;;;;;;;;;;;:3;:43::i;2181:459::-;2239:7;2480:6;2476:45;;-1:-1:-1;2509:1:0;2502:8;;2476:45;2543:5;;;2547:1;2543;:5;:1;2566:5;;;;;:10;2558:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;875:176;933:7;964:5;;;987:6;;;;979:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5178:929:4;5283:6;5273:16;;:6;:16;;;;:30;;;;;5302:1;5293:6;:10;5273:30;5269:832;;;5323:20;;;;5319:379;;5429:22;;;5410:16;5429:22;;;:14;:22;;;;;;;;;5489:13;:60;;5548:1;5489:60;;;5505:19;;;;;;;:11;:19;;;;;;;;:34;5525:13;;;5505:34;;;;;;;;5537:1;5505:40;;5489:60;5469:80;-1:-1:-1;5567:17:4;5587:21;5469:80;5601:6;5587:21;:13;:21;:::i;:::-;5567:41;;5626:57;5643:6;5651:9;5662;5673;5626:16;:57::i;:::-;5319:379;;;;5716:20;;;;5712:379;;5822:22;;;5803:16;5822:22;;;:14;:22;;;;;;;;;5882:13;:60;;5941:1;5882:60;;;5898:19;;;;;;;:11;:19;;;;;;;;:34;5918:13;;;5898:34;;;;;;;;5930:1;5898:40;;5882:60;5862:80;-1:-1:-1;5960:17:4;5980:21;5862:80;5994:6;5980:21;:13;:21;:::i;:::-;5960:41;;6019:57;6036:6;6044:9;6055;6066;6019:16;:57::i;5712:379::-;5178:929;;;:::o;2061:775:1:-;2178:44;2195:26;:6;2206:14;2195:10;:26::i;:::-;2178:12;;;:44;:16;:44;:::i;:::-;2163:12;:59;2315:19;;2261:18;;2282:53;;:28;:6;1421::7;2282:28:1;:10;:28;:::i;:53::-;2386:10;;2261:74;;-1:-1:-1;2386:26:1;;2261:74;2386:26;:14;:26;:::i;:::-;2373:10;:39;2516:19;:17;:19::i;:::-;2493;;:42;;2485:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2617:18;;;;;;;:14;:18;;;;;;:34;;2640:10;2617:34;:22;:34;:::i;:::-;2596:18;;;;;;;:14;:18;;;;;;;;:55;;;;2664:32;;;;;;;2596:18;;;;2664:32;;;;;;;;;;2773:14;;;;2769:1;2773:14;;;:10;:14;;;;;;2746:54;;2773:14;2789:10;2746:14;:54::i;:::-;2813:16;;;;;;;;;;;;;;;;;;;;;;;;;;;2061:775;;;:::o;4738:434:4:-;4852:21;;;;4826:23;4852:21;;;:10;:21;;;;;;;;;;4910:14;:25;;;;;;4991:21;;;;:33;;;;;;;;;;;5040:54;;4852:21;;;;;4910:25;;4991:33;;4852:21;;;5040:54;;4826:23;5040:54;5105:60;5120:15;5137:9;5148:16;5105:14;:60::i;:::-;4738:434;;;;:::o;6970:149::-;7078:9;6970:149;:::o;3714:272:0:-;3800:7;3834:12;3827:5;3819:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;3819:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3857:9;3873:1;3869;:5;;;;;;;3714:272;-1:-1:-1;;;;;3714:272:0:o;1747:187::-;1833:7;1868:12;1860:6;;;;1852:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;1852:29:0;-1:-1:-1;;;1903:5:0;;;1747:187::o;6113:687:4:-;6284:18;6305:77;6312:12;6305:77;;;;;;;;;;;;;;;;;:6;:77::i;:::-;6284:98;;6412:1;6397:12;:16;;;:85;;;;-1:-1:-1;6417:22:4;;;;;;;:11;:22;;;;;;;;:65;6440:16;;;6417:40;;;;;;;;;:50;:65;;;:50;;:65;6397:85;6393:334;;;6498:22;;;;;;;:11;:22;;;;;;;;:40;6521:16;;;6498:40;;;;;;;;6536:1;6498:46;:57;;;6393:334;;;6625:33;;;;;;;;;;;;;;;;;;;;;6586:22;;;-1:-1:-1;6586:22:4;;;:11;:22;;;;;:36;;;;;;;;;;:72;;;;;;;;;;;;;;;;;;;;;6672:25;;;:14;:25;;;;;;:44;;6700:16;;;6672:44;;;;;;;;;;6393:334;6742:51;;;;;;;;;;;;;;;;;;;;;;;;;;6113:687;;;;;:::o;6806:158::-;6881:6;6918:12;6911:5;6907:9;;6899:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;6899:32:4;-1:-1:-1;6955:1:4;;6806:158;-1:-1:-1;;6806:158:4:o;1429:1020:2:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1429:1020:2;;;-1:-1:-1;1429:1020:2;:::i;:::-;;;:::o;:::-;;;;;;;;;;-1:-1:-1;1429:1020:2;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;