Contract 0x8302FE9F0C509a996573D3Cc5B0D5D51e4FDD5eC

/**
 *Submitted for verification at Etherscan.io on 2020-05-29
*/

/*
   ____            __   __        __   _
  / __/__ __ ___  / /_ / /  ___  / /_ (_)__ __
 _\ \ / // // _ \/ __// _ \/ -_)/ __// / \ \ /
/___/ \_, //_//_/\__//_//_/\__/ \__//_/ /_\_\
     /___/

* Staking Rewards for UNI-V2 sGOLD Liquidity Providers 
* Synthetix: StakingRewards.sol
*
* Latest source (may be newer): https://github.com/Synthetixio/synthetix/blob/master/contracts/StakingRewards.sol
* Docs: https://docs.synthetix.io/contracts/StakingRewards
*
* Contract Dependencies: 
*	- Owned
*	- ReentrancyGuard
*	- RewardsDistributionRecipient
*	- TokenWrapper
* Libraries: 
*	- Address
*	- Math
*	- SafeERC20
*	- SafeMath
*
* MIT License
* ===========
*
* Copyright (c) 2020 Synthetix
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*/

/* ===============================================
* Flattened with Solidifier by Coinage
* 
* https://solidifier.coina.ge
* ===============================================
*/


pragma solidity ^0.5.0;

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

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

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


/**
 * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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-solidity/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) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}


/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the `nonReentrant` modifier
 * available, which can be aplied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 */
contract ReentrancyGuard {
    /// @dev counter to allow mutex lock with only one SSTORE operation
    uint256 private _guardCounter;

    constructor () internal {
        // The counter starts at one to prevent changing it from zero to a non-zero
        // value, which is a more expensive operation.
        _guardCounter = 1;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _guardCounter += 1;
        uint256 localCounter = _guardCounter;
        _;
        require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
    }
}


interface IERC20 {
    // ERC20 Optional Views
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    // Views
    function totalSupply() external view returns (uint);

    function balanceOf(address owner) external view returns (uint);

    function allowance(address owner, address spender) external view returns (uint);

    // Mutative functions
    function transfer(address to, uint value) external returns (bool);

    function approve(address spender, uint value) external returns (bool);

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

    // Events
    event Transfer(address indexed from, address indexed to, uint value);

    event Approval(address indexed owner, address indexed spender, uint value);
}


/**
 * @dev Collection of functions related to the address type,
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing a contract.
     *
     * > It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}


library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

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

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

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

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

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


// https://docs.synthetix.io/contracts/Owned
contract Owned {
    address public owner;
    address public nominatedOwner;

    constructor(address _owner) public {
        require(_owner != address(0), "Owner address cannot be 0");
        owner = _owner;
        emit OwnerChanged(address(0), _owner);
    }

    function nominateNewOwner(address _owner) external onlyOwner {
        nominatedOwner = _owner;
        emit OwnerNominated(_owner);
    }

    function acceptOwnership() external {
        require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
        emit OwnerChanged(owner, nominatedOwner);
        owner = nominatedOwner;
        nominatedOwner = address(0);
    }

    modifier onlyOwner {
        require(msg.sender == owner, "Only the contract owner may perform this action");
        _;
    }

    event OwnerNominated(address newOwner);
    event OwnerChanged(address oldOwner, address newOwner);
}


// Inheritance


// https://docs.synthetix.io/contracts/RewardsDistributionRecipient
contract RewardsDistributionRecipient is Owned {
    address public rewardsDistribution;

    function notifyRewardAmount(uint256 reward) external;

    modifier onlyRewardsDistribution() {
        require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
        _;
    }

    function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
        rewardsDistribution = _rewardsDistribution;
    }
}


contract TokenWrapper is ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    IERC20 public stakingToken;

    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;

    constructor(address _stakingToken) public {
        stakingToken = IERC20(_stakingToken);
    }

    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    function stake(uint256 amount) public nonReentrant {
        _totalSupply = _totalSupply.add(amount);
        _balances[msg.sender] = _balances[msg.sender].add(amount);
        stakingToken.safeTransferFrom(msg.sender, address(this), amount);
    }

    function withdraw(uint256 amount) public nonReentrant {
        _totalSupply = _totalSupply.sub(amount);
        _balances[msg.sender] = _balances[msg.sender].sub(amount);
        stakingToken.safeTransfer(msg.sender, amount);
    }
}


contract StakingRewards is TokenWrapper, RewardsDistributionRecipient {
    IERC20 public rewardsToken;

    uint256 public constant DURATION = 7 days;

    uint256 public periodFinish = 0;
    uint256 public rewardRate = 0;
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;
    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;

    event RewardAdded(uint256 reward);
    event Staked(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);

    constructor(
        address _owner,
        address _rewardsToken, 
        address _stakingToken
    ) public TokenWrapper(_stakingToken) Owned(_owner) {
        rewardsToken = IERC20(_rewardsToken);
    }

    modifier updateReward(address account) {
        rewardPerTokenStored = rewardPerToken();
        lastUpdateTime = lastTimeRewardApplicable();
        if (account != address(0)) {
            rewards[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
        _;
    }

    function lastTimeRewardApplicable() public view returns (uint256) {
        return Math.min(block.timestamp, periodFinish);
    }

    function rewardPerToken() public view returns (uint256) {
        if (totalSupply() == 0) {
            return rewardPerTokenStored;
        }
        return
            rewardPerTokenStored.add(
                lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(totalSupply())
            );
    }

    function earned(address account) public view returns (uint256) {
        return balanceOf(account).mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
    }

    // stake visibility is public as overriding LPTokenWrapper's stake() function
    function stake(uint256 amount) public updateReward(msg.sender) {
        require(amount > 0, "Cannot stake 0");
        super.stake(amount);
        emit Staked(msg.sender, amount);
    }

    function withdraw(uint256 amount) public updateReward(msg.sender) {
        require(amount > 0, "Cannot withdraw 0");
        super.withdraw(amount);
        emit Withdrawn(msg.sender, amount);
    }

    function exit() external {
        withdraw(balanceOf(msg.sender));
        getReward();
    }

    function getReward() public updateReward(msg.sender) {
        uint256 reward = earned(msg.sender);
        if (reward > 0) {
            rewards[msg.sender] = 0;
            rewardsToken.safeTransfer(msg.sender, reward);
            emit RewardPaid(msg.sender, reward);
        }
    }

    function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) {
        if (block.timestamp >= periodFinish) {
            rewardRate = reward.div(DURATION);
        } else {
            uint256 remaining = periodFinish.sub(block.timestamp);
            uint256 leftover = remaining.mul(rewardRate);
            rewardRate = reward.add(leftover).div(DURATION);
        }
        lastUpdateTime = block.timestamp;
        periodFinish = block.timestamp.add(DURATION);
        emit RewardAdded(reward);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_rewardsToken","type":"address"},{"internalType":"address","name":"_stakingToken","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"constant":true,"inputs":[],"name":"DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"acceptOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"exit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"getReward","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"nominateNewOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"nominatedOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"reward","type":"uint256"}],"name":"notifyRewardAmount","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rewardsDistribution","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rewardsToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_rewardsDistribution","type":"address"}],"name":"setRewardsDistribution","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"stakingToken","outputs":[{"internalType":"contract IERC20","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":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000de910777c787903f78c89e7a0bf7f4c435cbb1fe000000000000000000000000c011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f00000000000000000000000034a0216c5057bc18e5d34d4405284564efd759b2

-----Decoded View---------------
Arg [0] : _owner (address): 0xde910777c787903f78c89e7a0bf7f4c435cbb1fe
Arg [1] : _rewardsToken (address): 0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f
Arg [2] : _stakingToken (address): 0x34a0216c5057bc18e5d34d4405284564efd759b2

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000de910777c787903f78c89e7a0bf7f4c435cbb1fe
Arg [1] : 000000000000000000000000c011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f
Arg [2] : 00000000000000000000000034a0216c5057bc18e5d34d4405284564efd759b2

15620:3352:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15620:3352:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17307:198;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;17307:198:0;-1:-1:-1;;;;;17307:198:0;;:::i;:::-;;;;;;;;;;;;;;;;15998:42;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;15998:42:0;-1:-1:-1;;;;;15998:42:0;;:::i;13319:141::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;13319:141:0;-1:-1:-1;;;;;13319:141:0;;:::i;:::-;;14898:91;;;:::i;14402:142::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14402:142:0;-1:-1:-1;;;;;14402:142:0;;:::i;15732:41::-;;;:::i;17795:203::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;17795:203:0;;:::i;18412:557::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;18412:557:0;;:::i;18111:293::-;;;:::i;14136:34::-;;;:::i;:::-;;;;-1:-1:-1;;;;;14136:34:0;;;;;;;;;;;;;;13088:29;;;:::i;14997:110::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14997:110:0;-1:-1:-1;;;;;14997:110:0;;:::i;14669:26::-;;;:::i;13468:271::-;;;:::i;15820:29::-;;;:::i;16828:131::-;;;:::i;15934:57::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;15934:57:0;-1:-1:-1;;;;;15934:57:0;;:::i;13061:20::-;;;:::i;17596:191::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;17596:191:0;;:::i;15856:29::-;;;:::i;16967:332::-;;;:::i;15697:26::-;;;:::i;15892:35::-;;;:::i;18006:97::-;;;:::i;15782:31::-;;;:::i;17307:198::-;-1:-1:-1;;;;;17480:16:0;;17361:7;17480:16;;;:7;:16;;;;;;;;;17432:22;:31;;;;;;17388:109;;17480:16;17388:87;;17470:4;;17388:77;;17411:53;;:16;:14;:16::i;:::-;:20;:53;:20;:53;:::i;:::-;17388:18;17398:7;17388:9;:18::i;:::-;:22;:77;:22;:77;:::i;:::-;:81;:87;:81;:87;:::i;:::-;:91;:109;:91;:109;:::i;:::-;17381:116;17307:198;-1:-1:-1;;17307:198:0:o;15998:42::-;;;;;;;;;;;;;:::o;13319:141::-;13799:5;;-1:-1:-1;;;;;13799:5:0;13785:10;:19;13777:79;;;;-1:-1:-1;;;13777:79:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13391:14;:23;;-1:-1:-1;;;;;13391:23:0;;-1:-1:-1;;;;;;13391:23:0;;;;;;;;13430:22;;;;;;;;;;;;;;;;13319:141;:::o;14898:91::-;14969:12;;14898:91;;:::o;14402:142::-;13799:5;;-1:-1:-1;;;;;13799:5:0;13785:10;:19;13777:79;;;;-1:-1:-1;;;13777:79:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14494:19;:42;;-1:-1:-1;;;;;;14494:42:0;-1:-1:-1;;;;;14494:42:0;;;;;;;;;;14402:142::o;15732:41::-;15767:6;15732:41;:::o;17795:203::-;17849:10;16563:16;:14;:16::i;:::-;16540:20;:39;16607:26;:24;:26::i;:::-;16590:14;:43;-1:-1:-1;;;;;16648:21:0;;;16644:157;;16705:15;16712:7;16705:6;:15::i;:::-;-1:-1:-1;;;;;16686:16:0;;;;;;:7;:16;;;;;;;;:34;;;;16769:20;;16735:22;:31;;;;;;:54;16644:157;17889:1;17880:6;:10;17872:40;;;;;-1:-1:-1;;;17872:40:0;;;;;;;;;;;;-1:-1:-1;;;17872:40:0;;;;;;;;;;;;;;;17923:22;17938:6;17923:14;:22::i;:::-;17961:29;;;;;;;;17971:10;;17961:29;;;;;;;;;;17795:203;;:::o;18412:557::-;14308:19;;-1:-1:-1;;;;;14308:19:0;14294:10;:33;14286:88;;;;-1:-1:-1;;;14286:88:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18510:1;16563:16;:14;:16::i;:::-;16540:20;:39;16607:26;:24;:26::i;:::-;16590:14;:43;-1:-1:-1;;;;;16648:21:0;;;16644:157;;16705:15;16712:7;16705:6;:15::i;:::-;-1:-1:-1;;;;;16686:16:0;;;;;;:7;:16;;;;;;;;:34;;;;16769:20;;16735:22;:31;;;;;;:54;16644:157;18548:12;;18529:15;:31;18525:304;;18590:20;:6;15767;18590:20;:10;:20;:::i;:::-;18577:10;:33;18525:304;;;18663:12;;18643:17;;18663:33;;18680:15;18663:33;:16;:33;:::i;:::-;18643:53;;18711:16;18730:25;18744:10;;18730:9;:13;;:25;;;;:::i;:::-;18711:44;-1:-1:-1;18783:34:0;15767:6;18783:20;:6;18711:44;18783:20;:10;:20;:::i;:34::-;18770:10;:47;-1:-1:-1;;18525:304:0;18856:15;18839:14;:32;;;18897:29;;15767:6;18897:29;:19;:29;:::i;:::-;18882:12;:44;18942:19;;;;;;;;;;;;;;;;;14385:1;18412:557;:::o;18111:293::-;18152:10;16563:16;:14;:16::i;:::-;16540:20;:39;16607:26;:24;:26::i;:::-;16590:14;:43;-1:-1:-1;;;;;16648:21:0;;;16644:157;;16705:15;16712:7;16705:6;:15::i;:::-;-1:-1:-1;;;;;16686:16:0;;;;;;:7;:16;;;;;;;;:34;;;;16769:20;;16735:22;:31;;;;;;:54;16644:157;18175:14;18192:18;18199:10;18192:6;:18::i;:::-;18175:35;-1:-1:-1;18225:10:0;;18221:176;;18260:10;18274:1;18252:19;;;:7;:19;;;;;:23;18290:12;;:45;;-1:-1:-1;;;;;18290:12:0;;;;18328:6;18290:25;:45::i;:::-;18355:30;;;;;;;;18366:10;;18355:30;;;;;;;;;;18221:176;16811:1;18111:293;:::o;14136:34::-;;;-1:-1:-1;;;;;14136:34:0;;:::o;13088:29::-;;;-1:-1:-1;;;;;13088:29:0;;:::o;14997:110::-;-1:-1:-1;;;;;15081:18:0;15054:7;15081:18;;;:9;:18;;;;;;;14997:110::o;14669:26::-;;;-1:-1:-1;;;;;14669:26:0;;:::o;13468:271::-;13537:14;;-1:-1:-1;;;;;13537:14:0;13523:10;:28;13515:94;;;;-1:-1:-1;;;13515:94:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13638:5;;13645:14;;13625:35;;;-1:-1:-1;;;;;13638:5:0;;;13625:35;;13645:14;;;;13625:35;;;;;;;;;;;;;;;;13679:14;;;13671:5;:22;;-1:-1:-1;;;;;;13671:22:0;;;-1:-1:-1;;;;;13679:14:0;;13671:22;;;;13704:27;;;13468:271::o;15820:29::-;;;;:::o;16828:131::-;16885:7;16912:39;16921:15;16938:12;;16912:8;:39::i;:::-;16905:46;;16828:131;:::o;15934:57::-;;;;;;;;;;;;;:::o;13061:20::-;;;-1:-1:-1;;;;;13061:20:0;;:::o;17596:191::-;17647:10;16563:16;:14;:16::i;:::-;16540:20;:39;16607:26;:24;:26::i;:::-;16590:14;:43;-1:-1:-1;;;;;16648:21:0;;;16644:157;;16705:15;16712:7;16705:6;:15::i;:::-;-1:-1:-1;;;;;16686:16:0;;;;;;:7;:16;;;;;;;;:34;;;;16769:20;;16735:22;:31;;;;;;:54;16644:157;17687:1;17678:6;:10;17670:37;;;;;-1:-1:-1;;;17670:37:0;;;;;;;;;;;;-1:-1:-1;;;17670:37:0;;;;;;;;;;;;;;;17718:19;17730:6;17718:11;:19::i;:::-;17753:26;;;;;;;;17760:10;;17753:26;;;;;;;;;;17596:191;;:::o;15856:29::-;;;;:::o;16967:332::-;17014:7;17038:13;:11;:13::i;:::-;17034:78;;-1:-1:-1;17080:20:0;;17073:27;;17034:78;17142:149;17185:91;17262:13;:11;:13::i;:::-;17185:72;17252:4;17185:62;17236:10;;17185:46;17216:14;;17185:26;:24;:26::i;:91::-;17142:20;;;:149;:24;:149;:::i;15697:26::-;;;-1:-1:-1;;;;;15697:26:0;;:::o;15892:35::-;;;;:::o;18006:97::-;18042:31;18051:21;18061:10;18051:9;:21::i;:::-;18042:8;:31::i;:::-;18084:11;:9;:11::i;:::-;18006:97::o;15782:31::-;;;;:::o;4063:184::-;4121:7;4154:1;4149;:6;;4141:49;;;;;-1:-1:-1;;;4141:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4213:5:0;;;4063:184::o;4498:470::-;4556:7;4800:6;4796:47;;-1:-1:-1;4830:1:0;4823:8;;4796:47;4867:5;;;4871:1;4867;:5;:1;4891:5;;;;;:10;4883:56;;;;-1:-1:-1;;;4883:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4959:1;4498:470;-1:-1:-1;;;4498:470:0:o;5436:333::-;5494:7;5593:1;5589;:5;5581:44;;;;;-1:-1:-1;;;5581:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;5636:9;5652:1;5648;:5;;;;;;;5436:333;-1:-1:-1;;;;5436:333:0:o;3607:181::-;3665:7;3697:5;;;3721:6;;;;3713:46;;;;;-1:-1:-1;;;3713:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;15375:236;7693:13;:18;;7710:1;7693:18;;;;;15455:12;;:24;;15472:6;15455:24;:16;:24;:::i;:::-;15440:12;:39;15524:10;15514:21;;;;:9;:21;;;;;;:33;;15540:6;15514:33;:25;:33;:::i;:::-;15500:10;15490:21;;;;:9;:21;;;;;:57;;;;15558:12;;:45;;-1:-1:-1;;;;;15558:12:0;;;;15596:6;15558:25;:45::i;:::-;7805:13;;7789:12;:29;7781:73;;;;;-1:-1:-1;;;7781:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;9876:176;9985:58;;;-1:-1:-1;;;;;9985:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;9985:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;9959:85:0;;9978:5;;9959:18;:85::i;:::-;9876:176;;;:::o;2348:106::-;2406:7;2437:1;2433;:5;:13;;2445:1;2433:13;;;-1:-1:-1;2441:1:0;;2426:20;-1:-1:-1;2348:106:0:o;15115:252::-;7693:13;:18;;7710:1;7693:18;;;;;15192:12;;:24;;15209:6;15192:24;:16;:24;:::i;:::-;15177:12;:39;15261:10;15251:21;;;;:9;:21;;;;;;:33;;15277:6;15251:33;:25;:33;:::i;:::-;15237:10;15227:21;;;;:9;:21;;;;;:57;;;;15295:12;;:64;;-1:-1:-1;;;;;15295:12:0;;;;15345:4;15352:6;15295:29;:64::i;11870:1114::-;12474:27;12482:5;-1:-1:-1;;;;;12474:25:0;;:27::i;:::-;12466:71;;;;;-1:-1:-1;;;12466:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;12611:12;12625:23;12660:5;-1:-1:-1;;;;;12652:19:0;12672:4;12652:25;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;12652:25:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;12610:67:0;;;;12696:7;12688:52;;;;;-1:-1:-1;;;12688:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12757:17;;:21;12753:224;;12899:10;12888:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;12888:30:0;12880:85;;;;-1:-1:-1;;;12880:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11870:1114;;;;:::o;10060:204::-;10187:68;;;-1:-1:-1;;;;;10187:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;10187:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;10161:95:0;;10180:5;;10161:18;:95::i;9353:422::-;9720:20;9759:8;;;9353:422::o

bzzr://87be768b68397d569f14b37b446f70ed273134df91e3555eecbbba3ae1d84231