Contract 0x3a941e1094b9e33efabb26a9047a8abb4b257907 1

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x21b9b2f374dc68fa9a151889dc9ed4991e804575cc2c031fe41c6d431c8c51550x60806040211972172022-08-25 0:23:1833 days 17 hrs agoLivepeer: Deployer IN  Create: BondingManager0 ETH0.008971759015 ETH
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x30fd7cc58da69a0acef2a35afd3c1c3b1220a88d0ba3d90ecd8c8be1f1535049270427172022-09-27 18:15:027 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x1b42c43183524e033bbaefa03aaf15ee00d1bb4de1415b8963f5cda5a7119a41270407722022-09-27 17:56:2326 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x4f2aa7ee997f9e1da3fe8e2527e343be376e17a27d8f240d98f0a81924166651270393722022-09-27 17:45:0837 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x9c49827c8541360fc41aecdd2081adac723929887efe4ba413ec4ec439b30121270391912022-09-27 17:43:3939 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x78b0de7ba60e8b871f843b10bbd21548ef968e77d1e29fb805755a853d70832b270364722022-09-27 17:20:081 hr 2 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0xa9762f5f4ffff1dd9739d922b01d672d8c85dbe241c63f1abc569ed343f97b3e270357792022-09-27 17:14:251 hr 8 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x9697b514b39bebfd98940f9b40efa395565144d3ac67d740afff4443451adecf270357112022-09-27 17:13:541 hr 8 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x2fc935fb0f4a41eda936cbd86e99b364dd4e510c73bee225a2c13a5d8c34713f270356362022-09-27 17:13:231 hr 9 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x8e2e4a086d44d291b7a83ce3664724bdb1499bd699a7cc1860bd90de32200492270337562022-09-27 17:00:381 hr 22 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x6e2ba0d4c09e2aa90b707d7a7b69b7de0f5632c87a4d1322f4277fea792f3bf6270335192022-09-27 16:59:061 hr 23 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0xeb16116868b3a679bf647d14564ae6da354efa70f0e5f319b2377f48e1e3c987270305782022-09-27 16:43:231 hr 39 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0xdebb87c203107af285fe9a3402679b2904b1809763f613bb438d73b7887340ca270267962022-09-27 16:22:491 hr 59 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x198676626ad7587f8e40e55e0862650d9dcb07dc3f29fc075db3105438f519f8270259392022-09-27 16:19:102 hrs 3 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0xfcd3c4619602bcd9179349348f8d2942fb16150b1b533200e522841df68fa7ce270251682022-09-27 16:16:032 hrs 6 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x2aec8e241beb03ea75a452a419ec95a8a4d2d580b2d2e17718d1eb5f257c9457270223692022-09-27 16:03:342 hrs 19 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x2817cd3959cae88e40fadbb97bd289dc68a04d27b4e3c5c49683651e1d6b616b270207632022-09-27 15:55:062 hrs 27 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0xfd2cfb46d1ce2c49b0c9c2967696ac30fafae5f3aea47c62192245ce155b7f17270194992022-09-27 15:46:342 hrs 36 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x6f1480a458790437305de48411931e81b5eadf3541adf3c316e92307cd906c8b270194622022-09-27 15:46:202 hrs 36 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x3b1cafb2fe08da4773c1f07223cb5fcf5b7bb98a73758ea217fbacd5836736b6270187692022-09-27 15:41:502 hrs 40 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0xecbc6155c27f3a9a3818d96f4274af2edb0d238474401e376987250ddf167ff5270182742022-09-27 15:38:382 hrs 44 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x90e27dad910f6651a436609a3f8bd413bf0c73fe5c3157046dc04597d5cbe453270180422022-09-27 15:37:072 hrs 45 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0xdeefb6e8b5df324a91f6527cd080d8cc6c3cd3776323eb096995ccc89f742390270162752022-09-27 15:26:062 hrs 56 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0xbbd91ed4de96dd3a7a5e78fa774aafafdc59d1040a8aee3d09793449c2692435270158712022-09-27 15:23:302 hrs 59 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x4fc19981bd5506e4e9ee9278e2b22e34a6a98f0be1ac7ac98a4015e986c8a580270136132022-09-27 15:09:253 hrs 13 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
0x82738007018f45bd4e391e87ad1e374ca5866b55861cbe8111c308527545ee93270135892022-09-27 15:09:173 hrs 13 mins ago Livepeer: Proxy Bonding Manager 0x3a941e1094b9e33efabb26a9047a8abb4b2579070 ETH
[ Download CSV Export 
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.

Contract Source Code Verified (Exact Match)

Contract Name:
BondingManager

Compiler Version
v0.8.9+commit.e5eed63a

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Arbiscan on 2022-08-25
*/

// Sources flattened with hardhat v2.8.3 https://hardhat.org

// File contracts/IManager.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;

interface IManager {
    event SetController(address controller);
    event ParameterUpdate(string param);

    function setController(address _controller) external;
}


// File contracts/zeppelin/Ownable.sol

pragma solidity 0.8.9;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
    address public owner;

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

    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
     * account.
     */
    constructor() {
        owner = msg.sender;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

    /**
     * @dev Allows the current owner to transfer control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0));
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }
}


// File contracts/zeppelin/Pausable.sol

pragma solidity 0.8.9;

/**
 * @title Pausable
 * @dev Base contract which allows children to implement an emergency stop mechanism.
 */
contract Pausable is Ownable {
    event Pause();
    event Unpause();

    bool public paused;

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     */
    modifier whenNotPaused() {
        require(!paused);
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     */
    modifier whenPaused() {
        require(paused);
        _;
    }

    /**
     * @dev called by the owner to pause, triggers stopped state
     */
    function pause() public onlyOwner whenNotPaused {
        paused = true;
        emit Pause();
    }

    /**
     * @dev called by the owner to unpause, returns to normal state
     */
    function unpause() public onlyOwner whenPaused {
        paused = false;
        emit Unpause();
    }
}


// File contracts/IController.sol

pragma solidity 0.8.9;

abstract contract IController is Pausable {
    event SetContractInfo(bytes32 id, address contractAddress, bytes20 gitCommitHash);

    function setContractInfo(
        bytes32 _id,
        address _contractAddress,
        bytes20 _gitCommitHash
    ) external virtual;

    function updateController(bytes32 _id, address _controller) external virtual;

    function getContract(bytes32 _id) public view virtual returns (address);
}


// File contracts/Manager.sol

pragma solidity 0.8.9;


contract Manager is IManager {
    // Controller that contract is registered with
    IController public controller;

    // Check if sender is controller
    modifier onlyController() {
        _onlyController();
        _;
    }

    // Check if sender is controller owner
    modifier onlyControllerOwner() {
        _onlyControllerOwner();
        _;
    }

    // Check if controller is not paused
    modifier whenSystemNotPaused() {
        _whenSystemNotPaused();
        _;
    }

    // Check if controller is paused
    modifier whenSystemPaused() {
        _whenSystemPaused();
        _;
    }

    constructor(address _controller) {
        controller = IController(_controller);
    }

    /**
     * @notice Set controller. Only callable by current controller
     * @param _controller Controller contract address
     */
    function setController(address _controller) external onlyController {
        controller = IController(_controller);

        emit SetController(_controller);
    }

    function _onlyController() private view {
        require(msg.sender == address(controller), "caller must be Controller");
    }

    function _onlyControllerOwner() private view {
        require(msg.sender == controller.owner(), "caller must be Controller owner");
    }

    function _whenSystemNotPaused() private view {
        require(!controller.paused(), "system is paused");
    }

    function _whenSystemPaused() private view {
        require(controller.paused(), "system is not paused");
    }
}


// File contracts/ManagerProxyTarget.sol

pragma solidity 0.8.9;

/**
 * @title ManagerProxyTarget
 * @notice The base contract that target contracts used by a proxy contract should inherit from
 * @dev Both the target contract and the proxy contract (implemented as ManagerProxy) MUST inherit from ManagerProxyTarget in order to guarantee
 that both contracts have the same storage layout. Differing storage layouts in a proxy contract and target contract can
 potentially break the delegate proxy upgradeability mechanism
 */
abstract contract ManagerProxyTarget is Manager {
    // Used to look up target contract address in controller's registry
    bytes32 public targetContractId;
}


// File contracts/bonding/IBondingManager.sol

pragma solidity 0.8.9;

/**
 * @title Interface for BondingManager
 * TODO: switch to interface type
 */
interface IBondingManager {
    event TranscoderUpdate(address indexed transcoder, uint256 rewardCut, uint256 feeShare);
    event TranscoderActivated(address indexed transcoder, uint256 activationRound);
    event TranscoderDeactivated(address indexed transcoder, uint256 deactivationRound);
    event TranscoderSlashed(address indexed transcoder, address finder, uint256 penalty, uint256 finderReward);
    event Reward(address indexed transcoder, uint256 amount);
    event Bond(
        address indexed newDelegate,
        address indexed oldDelegate,
        address indexed delegator,
        uint256 additionalAmount,
        uint256 bondedAmount
    );
    event Unbond(
        address indexed delegate,
        address indexed delegator,
        uint256 unbondingLockId,
        uint256 amount,
        uint256 withdrawRound
    );
    event Rebond(address indexed delegate, address indexed delegator, uint256 unbondingLockId, uint256 amount);
    event TransferBond(
        address indexed oldDelegator,
        address indexed newDelegator,
        uint256 oldUnbondingLockId,
        uint256 newUnbondingLockId,
        uint256 amount
    );
    event WithdrawStake(address indexed delegator, uint256 unbondingLockId, uint256 amount, uint256 withdrawRound);
    event WithdrawFees(address indexed delegator, address recipient, uint256 amount);
    event EarningsClaimed(
        address indexed delegate,
        address indexed delegator,
        uint256 rewards,
        uint256 fees,
        uint256 startRound,
        uint256 endRound
    );

    // Deprecated events
    // These event signatures can be used to construct the appropriate topic hashes to filter for past logs corresponding
    // to these deprecated events.
    // event Bond(address indexed delegate, address indexed delegator);
    // event Unbond(address indexed delegate, address indexed delegator);
    // event WithdrawStake(address indexed delegator);
    // event TranscoderUpdate(address indexed transcoder, uint256 pendingRewardCut, uint256 pendingFeeShare, uint256 pendingPricePerSegment, bool registered);
    // event TranscoderEvicted(address indexed transcoder);
    // event TranscoderResigned(address indexed transcoder);

    // External functions
    function updateTranscoderWithFees(
        address _transcoder,
        uint256 _fees,
        uint256 _round
    ) external;

    function slashTranscoder(
        address _transcoder,
        address _finder,
        uint256 _slashAmount,
        uint256 _finderFee
    ) external;

    function setCurrentRoundTotalActiveStake() external;

    // Public functions
    function getTranscoderPoolSize() external view returns (uint256);

    function transcoderTotalStake(address _transcoder) external view returns (uint256);

    function isActiveTranscoder(address _transcoder) external view returns (bool);

    function getTotalBonded() external view returns (uint256);
}


// File @openzeppelin/contracts/utils/math/[email protected]

// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // 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 (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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) {
        return a + b;
    }

    /**
     * @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 a - b;
    }

    /**
     * @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) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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 a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}


// File contracts/libraries/SortedDoublyLL.sol

pragma solidity 0.8.9;

/**
 * @title A sorted doubly linked list with nodes sorted in descending order. Optionally accepts insert position hints
 *
 * Given a new node with a `key`, a hint is of the form `(prevId, nextId)` s.t. `prevId` and `nextId` are adjacent in the list.
 * `prevId` is a node with a key >= `key` and `nextId` is a node with a key <= `key`. If the sender provides a hint that is a valid insert position
 * the insert operation is a constant time storage write. However, the provided hint in a given transaction might be a valid insert position, but if other transactions are included first, when
 * the given transaction is executed the provided hint may no longer be a valid insert position. For example, one of the nodes referenced might be removed or their keys may
 * be updated such that the the pair of nodes in the hint no longer represent a valid insert position. If one of the nodes in the hint becomes invalid, we still try to use the other
 * valid node as a starting point for finding the appropriate insert position. If both nodes in the hint become invalid, we use the head of the list as a starting point
 * to find the appropriate insert position.
 */
library SortedDoublyLL {
    using SafeMath for uint256;

    // Information for a node in the list
    struct Node {
        uint256 key; // Node's key used for sorting
        address nextId; // Id of next node (smaller key) in the list
        address prevId; // Id of previous node (larger key) in the list
    }

    // Information for the list
    struct Data {
        address head; // Head of the list. Also the node in the list with the largest key
        address tail; // Tail of the list. Also the node in the list with the smallest key
        uint256 maxSize; // Maximum size of the list
        uint256 size; // Current size of the list
        mapping(address => Node) nodes; // Track the corresponding ids for each node in the list
    }

    /**
     * @dev Set the maximum size of the list
     * @param _size Maximum size
     */
    function setMaxSize(Data storage self, uint256 _size) public {
        require(_size > self.maxSize, "new max size must be greater than old max size");

        self.maxSize = _size;
    }

    /**
     * @dev Add a node to the list
     * @param _id Node's id
     * @param _key Node's key
     * @param _prevId Id of previous node for the insert position
     * @param _nextId Id of next node for the insert position
     */
    function insert(
        Data storage self,
        address _id,
        uint256 _key,
        address _prevId,
        address _nextId
    ) public {
        // List must not be full
        require(!isFull(self), "list is full");
        // List must not already contain node
        require(!contains(self, _id), "node already in list");
        // Node id must not be null
        require(_id != address(0), "node id is null");
        // Key must be non-zero
        require(_key > 0, "key is zero");

        address prevId = _prevId;
        address nextId = _nextId;

        if (!validInsertPosition(self, _key, prevId, nextId)) {
            // Sender's hint was not a valid insert position
            // Use sender's hint to find a valid insert position
            (prevId, nextId) = findInsertPosition(self, _key, prevId, nextId);
        }

        self.nodes[_id].key = _key;

        if (prevId == address(0) && nextId == address(0)) {
            // Insert as head and tail
            self.head = _id;
            self.tail = _id;
        } else if (prevId == address(0)) {
            // Insert before `prevId` as the head
            self.nodes[_id].nextId = self.head;
            self.nodes[self.head].prevId = _id;
            self.head = _id;
        } else if (nextId == address(0)) {
            // Insert after `nextId` as the tail
            self.nodes[_id].prevId = self.tail;
            self.nodes[self.tail].nextId = _id;
            self.tail = _id;
        } else {
            // Insert at insert position between `prevId` and `nextId`
            self.nodes[_id].nextId = nextId;
            self.nodes[_id].prevId = prevId;
            self.nodes[prevId].nextId = _id;
            self.nodes[nextId].prevId = _id;
        }

        self.size = self.size.add(1);
    }

    /**
     * @dev Remove a node from the list
     * @param _id Node's id
     */
    function remove(Data storage self, address _id) public {
        // List must contain the node
        require(contains(self, _id), "node not in list");

        if (self.size > 1) {
            // List contains more than a single node
            if (_id == self.head) {
                // The removed node is the head
                // Set head to next node
                self.head = self.nodes[_id].nextId;
                // Set prev pointer of new head to null
                self.nodes[self.head].prevId = address(0);
            } else if (_id == self.tail) {
                // The removed node is the tail
                // Set tail to previous node
                self.tail = self.nodes[_id].prevId;
                // Set next pointer of new tail to null
                self.nodes[self.tail].nextId = address(0);
            } else {
                // The removed node is neither the head nor the tail
                // Set next pointer of previous node to the next node
                self.nodes[self.nodes[_id].prevId].nextId = self.nodes[_id].nextId;
                // Set prev pointer of next node to the previous node
                self.nodes[self.nodes[_id].nextId].prevId = self.nodes[_id].prevId;
            }
        } else {
            // List contains a single node
            // Set the head and tail to null
            self.head = address(0);
            self.tail = address(0);
        }

        delete self.nodes[_id];
        self.size = self.size.sub(1);
    }

    /**
     * @dev Update the key of a node in the list
     * @param _id Node's id
     * @param _newKey Node's new key
     * @param _prevId Id of previous node for the new insert position
     * @param _nextId Id of next node for the new insert position
     */
    function updateKey(
        Data storage self,
        address _id,
        uint256 _newKey,
        address _prevId,
        address _nextId
    ) public {
        // List must contain the node
        require(contains(self, _id), "node not in list");

        // Remove node from the list
        remove(self, _id);

        if (_newKey > 0) {
            // Insert node if it has a non-zero key
            insert(self, _id, _newKey, _prevId, _nextId);
        }
    }

    /**
     * @dev Checks if the list contains a node
     * @param _id Address of transcoder
     * @return true if '_id' is in list
     */
    function contains(Data storage self, address _id) public view returns (bool) {
        // List only contains non-zero keys, so if key is non-zero the node exists
        return self.nodes[_id].key > 0;
    }

    /**
     * @dev Checks if the list is full
     * @return true if list is full
     */
    function isFull(Data storage self) public view returns (bool) {
        return self.size == self.maxSize;
    }

    /**
     * @dev Checks if the list is empty
     * @return true if list is empty
     */
    function isEmpty(Data storage self) public view returns (bool) {
        return self.size == 0;
    }

    /**
     * @dev Returns the current size of the list
     * @return current size of the list
     */
    function getSize(Data storage self) public view returns (uint256) {
        return self.size;
    }

    /**
     * @dev Returns the maximum size of the list
     */
    function getMaxSize(Data storage self) public view returns (uint256) {
        return self.maxSize;
    }

    /**
     * @dev Returns the key of a node in the list
     * @param _id Node's id
     * @return key for node with '_id'
     */
    function getKey(Data storage self, address _id) public view returns (uint256) {
        return self.nodes[_id].key;
    }

    /**
     * @dev Returns the first node in the list (node with the largest key)
     * @return address for the head of the list
     */
    function getFirst(Data storage self) public view returns (address) {
        return self.head;
    }

    /**
     * @dev Returns the last node in the list (node with the smallest key)
     * @return address for the tail of the list
     */
    function getLast(Data storage self) public view returns (address) {
        return self.tail;
    }

    /**
     * @dev Returns the next node (with a smaller key) in the list for a given node
     * @param _id Node's id
     * @return address for the node following node in list with '_id'
     */
    function getNext(Data storage self, address _id) public view returns (address) {
        return self.nodes[_id].nextId;
    }

    /**
     * @dev Returns the previous node (with a larger key) in the list for a given node
     * @param _id Node's id
     * address for the node before node in list with '_id'
     */
    function getPrev(Data storage self, address _id) public view returns (address) {
        return self.nodes[_id].prevId;
    }

    /**
     * @dev Check if a pair of nodes is a valid insertion point for a new node with the given key
     * @param _key Node's key
     * @param _prevId Id of previous node for the insert position
     * @param _nextId Id of next node for the insert position
     * @return if the insert position is valid
     */
    function validInsertPosition(
        Data storage self,
        uint256 _key,
        address _prevId,
        address _nextId
    ) public view returns (bool) {
        if (_prevId == address(0) && _nextId == address(0)) {
            // `(null, null)` is a valid insert position if the list is empty
            return isEmpty(self);
        } else if (_prevId == address(0)) {
            // `(null, _nextId)` is a valid insert position if `_nextId` is the head of the list
            return self.head == _nextId && _key >= self.nodes[_nextId].key;
        } else if (_nextId == address(0)) {
            // `(_prevId, null)` is a valid insert position if `_prevId` is the tail of the list
            return self.tail == _prevId && _key <= self.nodes[_prevId].key;
        } else {
            // `(_prevId, _nextId)` is a valid insert position if they are adjacent nodes and `_key` falls between the two nodes' keys
            return
                self.nodes[_prevId].nextId == _nextId &&
                self.nodes[_prevId].key >= _key &&
                _key >= self.nodes[_nextId].key;
        }
    }

    /**
     * @dev Descend the list (larger keys to smaller keys) to find a valid insert position
     * @param _key Node's key
     * @param _startId Id of node to start ascending the list from
     */
    function descendList(
        Data storage self,
        uint256 _key,
        address _startId
    ) private view returns (address, address) {
        // If `_startId` is the head, check if the insert position is before the head
        if (self.head == _startId && _key >= self.nodes[_startId].key) {
            return (address(0), _startId);
        }

        address prevId = _startId;
        address nextId = self.nodes[prevId].nextId;

        // Descend the list until we reach the end or until we find a valid insert position
        while (prevId != address(0) && !validInsertPosition(self, _key, prevId, nextId)) {
            prevId = self.nodes[prevId].nextId;
            nextId = self.nodes[prevId].nextId;
        }

        return (prevId, nextId);
    }

    /**
     * @dev Ascend the list (smaller keys to larger keys) to find a valid insert position
     * @param _key Node's key
     * @param _startId Id of node to start descending the list from
     */
    function ascendList(
        Data storage self,
        uint256 _key,
        address _startId
    ) private view returns (address, address) {
        // If `_startId` is the tail, check if the insert position is after the tail
        if (self.tail == _startId && _key <= self.nodes[_startId].key) {
            return (_startId, address(0));
        }

        address nextId = _startId;
        address prevId = self.nodes[nextId].prevId;

        // Ascend the list until we reach the end or until we find a valid insertion point
        while (nextId != address(0) && !validInsertPosition(self, _key, prevId, nextId)) {
            nextId = self.nodes[nextId].prevId;
            prevId = self.nodes[nextId].prevId;
        }

        return (prevId, nextId);
    }

    /**
     * @dev Find the insert position for a new node with the given key
     * @param _key Node's key
     * @param _prevId Id of previous node for the insert position
     * @param _nextId Id of next node for the insert position
     */
    function findInsertPosition(
        Data storage self,
        uint256 _key,
        address _prevId,
        address _nextId
    ) private view returns (address, address) {
        address prevId = _prevId;
        address nextId = _nextId;

        if (prevId != address(0)) {
            if (!contains(self, prevId) || _key > self.nodes[prevId].key) {
                // `prevId` does not exist anymore or now has a smaller key than the given key
                prevId = address(0);
            }
        }

        if (nextId != address(0)) {
            if (!contains(self, nextId) || _key < self.nodes[nextId].key) {
                // `nextId` does not exist anymore or now has a larger key than the given key
                nextId = address(0);
            }
        }

        if (prevId == address(0) && nextId == address(0)) {
            // No hint - descend list starting from head
            return descendList(self, _key, self.head);
        } else if (prevId == address(0)) {
            // No `prevId` for hint - ascend list starting from `nextId`
            return ascendList(self, _key, nextId);
        } else if (nextId == address(0)) {
            // No `nextId` for hint - descend list starting from `prevId`
            return descendList(self, _key, prevId);
        } else {
            // Descend list starting from `prevId`
            return descendList(self, _key, prevId);
        }
    }
}


// File contracts/libraries/MathUtils.sol

pragma solidity 0.8.9;

library MathUtils {
    using SafeMath for uint256;

    // Divisor used for representing percentages
    uint256 public constant PERC_DIVISOR = 1000000;

    /**
     * @dev Returns whether an amount is a valid percentage out of PERC_DIVISOR
     * @param _amount Amount that is supposed to be a percentage
     */
    function validPerc(uint256 _amount) internal pure returns (bool) {
        return _amount <= PERC_DIVISOR;
    }

    /**
     * @dev Compute percentage of a value with the percentage represented by a fraction
     * @param _amount Amount to take the percentage of
     * @param _fracNum Numerator of fraction representing the percentage
     * @param _fracDenom Denominator of fraction representing the percentage
     */
    function percOf(
        uint256 _amount,
        uint256 _fracNum,
        uint256 _fracDenom
    ) internal pure returns (uint256) {
        return _amount.mul(percPoints(_fracNum, _fracDenom)).div(PERC_DIVISOR);
    }

    /**
     * @dev Compute percentage of a value with the percentage represented by a fraction over PERC_DIVISOR
     * @param _amount Amount to take the percentage of
     * @param _fracNum Numerator of fraction representing the percentage with PERC_DIVISOR as the denominator
     */
    function percOf(uint256 _amount, uint256 _fracNum) internal pure returns (uint256) {
        return _amount.mul(_fracNum).div(PERC_DIVISOR);
    }

    /**
     * @dev Compute percentage representation of a fraction
     * @param _fracNum Numerator of fraction represeting the percentage
     * @param _fracDenom Denominator of fraction represeting the percentage
     */
    function percPoints(uint256 _fracNum, uint256 _fracDenom) internal pure returns (uint256) {
        return _fracNum.mul(PERC_DIVISOR).div(_fracDenom);
    }
}


// File contracts/libraries/PreciseMathUtils.sol

pragma solidity 0.8.9;

library PreciseMathUtils {
    using SafeMath for uint256;

    // Divisor used for representing percentages
    uint256 public constant PERC_DIVISOR = 10**27;

    /**
     * @dev Returns whether an amount is a valid percentage out of PERC_DIVISOR
     * @param _amount Amount that is supposed to be a percentage
     */
    function validPerc(uint256 _amount) internal pure returns (bool) {
        return _amount <= PERC_DIVISOR;
    }

    /**
     * @dev Compute percentage of a value with the percentage represented by a fraction
     * @param _amount Amount to take the percentage of
     * @param _fracNum Numerator of fraction representing the percentage
     * @param _fracDenom Denominator of fraction representing the percentage
     */
    function percOf(
        uint256 _amount,
        uint256 _fracNum,
        uint256 _fracDenom
    ) internal pure returns (uint256) {
        return _amount.mul(percPoints(_fracNum, _fracDenom)).div(PERC_DIVISOR);
    }

    /**
     * @dev Compute percentage of a value with the percentage represented by a fraction over PERC_DIVISOR
     * @param _amount Amount to take the percentage of
     * @param _fracNum Numerator of fraction representing the percentage with PERC_DIVISOR as the denominator
     */
    function percOf(uint256 _amount, uint256 _fracNum) internal pure returns (uint256) {
        return _amount.mul(_fracNum).div(PERC_DIVISOR);
    }

    /**
     * @dev Compute percentage representation of a fraction
     * @param _fracNum Numerator of fraction represeting the percentage
     * @param _fracDenom Denominator of fraction represeting the percentage
     */
    function percPoints(uint256 _fracNum, uint256 _fracDenom) internal pure returns (uint256) {
        return _fracNum.mul(PERC_DIVISOR).div(_fracDenom);
    }
}


// File contracts/bonding/libraries/EarningsPool.sol

pragma solidity 0.8.9;

/**
 * @title EarningsPool
 * @dev Manages reward and fee pools for delegators and transcoders
 */
library EarningsPool {
    using SafeMath for uint256;

    struct Data {
        uint256 totalStake; // Transcoder's total stake during the earnings pool's round
        uint256 transcoderRewardCut; // Transcoder's reward cut during the earnings pool's round
        uint256 transcoderFeeShare; // Transcoder's fee share during the earnings pool's round
        // LIP-36 (https://github.com/livepeer/LIPs/blob/master/LIPs/LIP-36.md) fields
        // See EarningsPoolLIP36.sol
        uint256 cumulativeRewardFactor;
        uint256 cumulativeFeeFactor;
    }

    /**
     * @dev Sets transcoderRewardCut and transcoderFeeshare for an EarningsPool
     * @param earningsPool Storage pointer to EarningsPool struct
     * @param _rewardCut Reward cut of transcoder during the earnings pool's round
     * @param _feeShare Fee share of transcoder during the earnings pool's round
     */
    function setCommission(
        EarningsPool.Data storage earningsPool,
        uint256 _rewardCut,
        uint256 _feeShare
    ) internal {
        earningsPool.transcoderRewardCut = _rewardCut;
        earningsPool.transcoderFeeShare = _feeShare;
    }

    /**
     * @dev Sets totalStake for an EarningsPool
     * @param earningsPool Storage pointer to EarningsPool struct
     * @param _stake Total stake of the transcoder during the earnings pool's round
     */
    function setStake(EarningsPool.Data storage earningsPool, uint256 _stake) internal {
        earningsPool.totalStake = _stake;
    }
}


// File contracts/bonding/libraries/EarningsPoolLIP36.sol

pragma solidity 0.8.9;


library EarningsPoolLIP36 {
    using SafeMath for uint256;

    /**
     * @notice Update the cumulative fee factor stored in an earnings pool with new fees
     * @param earningsPool Storage pointer to EarningsPools.Data struct
     * @param _prevEarningsPool In-memory EarningsPool.Data struct that stores the previous cumulative reward and fee factors
     * @param _fees Amount of new fees
     */
    function updateCumulativeFeeFactor(
        EarningsPool.Data storage earningsPool,
        EarningsPool.Data memory _prevEarningsPool,
        uint256 _fees
    ) internal {
        uint256 prevCumulativeFeeFactor = _prevEarningsPool.cumulativeFeeFactor;
        uint256 prevCumulativeRewardFactor = _prevEarningsPool.cumulativeRewardFactor != 0
            ? _prevEarningsPool.cumulativeRewardFactor
            : PreciseMathUtils.percPoints(1, 1);

        // Initialize the cumulativeFeeFactor when adding fees for the first time
        if (earningsPool.cumulativeFeeFactor == 0) {
            earningsPool.cumulativeFeeFactor = prevCumulativeFeeFactor.add(
                PreciseMathUtils.percOf(prevCumulativeRewardFactor, _fees, earningsPool.totalStake)
            );
            return;
        }

        earningsPool.cumulativeFeeFactor = earningsPool.cumulativeFeeFactor.add(
            PreciseMathUtils.percOf(prevCumulativeRewardFactor, _fees, earningsPool.totalStake)
        );
    }

    /**
     * @notice Update the cumulative reward factor stored in an earnings pool with new rewards
     * @param earningsPool Storage pointer to EarningsPool.Data struct
     * @param _prevEarningsPool Storage pointer to EarningsPool.Data struct that stores the previous cumulative reward factor
     * @param _rewards Amount of new rewards
     */
    function updateCumulativeRewardFactor(
        EarningsPool.Data storage earningsPool,
        EarningsPool.Data memory _prevEarningsPool,
        uint256 _rewards
    ) internal {
        uint256 prevCumulativeRewardFactor = _prevEarningsPool.cumulativeRewardFactor != 0
            ? _prevEarningsPool.cumulativeRewardFactor
            : PreciseMathUtils.percPoints(1, 1);

        earningsPool.cumulativeRewardFactor = prevCumulativeRewardFactor.add(
            PreciseMathUtils.percOf(prevCumulativeRewardFactor, _rewards, earningsPool.totalStake)
        );
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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


// File contracts/token/ILivepeerToken.sol

pragma solidity 0.8.9;

interface ILivepeerToken is IERC20 {
    function mint(address _to, uint256 _amount) external;

    function burn(uint256 _amount) external;
}


// File contracts/token/IMinter.sol

pragma solidity 0.8.9;

/**
 * @title Minter interface
 */
interface IMinter {
    // Events
    event SetCurrentRewardTokens(uint256 currentMintableTokens, uint256 currentInflation);

    // External functions
    function createReward(uint256 _fracNum, uint256 _fracDenom) external returns (uint256);

    function trustedTransferTokens(address _to, uint256 _amount) external;

    function trustedBurnTokens(uint256 _amount) external;

    function trustedWithdrawETH(address payable _to, uint256 _amount) external;

    function depositETH() external payable returns (bool);

    function setCurrentRewardTokens() external;

    function currentMintableTokens() external view returns (uint256);

    function currentMintedTokens() external view returns (uint256);

    // Public functions
    function getController() external view returns (IController);
}


// File contracts/rounds/IRoundsManager.sol

pragma solidity 0.8.9;

/**
 * @title RoundsManager interface
 */
interface IRoundsManager {
    // Events
    event NewRound(uint256 indexed round, bytes32 blockHash);

    // Deprecated events
    // These event signatures can be used to construct the appropriate topic hashes to filter for past logs corresponding
    // to these deprecated events.
    // event NewRound(uint256 round)

    // External functions
    function initializeRound() external;

    function lipUpgradeRound(uint256 _lip) external view returns (uint256);

    // Public functions
    function blockNum() external view returns (uint256);

    function blockHash(uint256 _block) external view returns (bytes32);

    function blockHashForRound(uint256 _round) external view returns (bytes32);

    function currentRound() external view returns (uint256);

    function currentRoundStartBlock() external view returns (uint256);

    function currentRoundInitialized() external view returns (bool);

    function currentRoundLocked() external view returns (bool);
}


// File contracts/snapshots/IMerkleSnapshot.sol

pragma solidity 0.8.9;

interface IMerkleSnapshot {
    function verify(
        bytes32 _id,
        bytes32[] calldata _proof,
        bytes32 _leaf
    ) external view returns (bool);
}


// File contracts/bonding/BondingManager.sol

pragma solidity 0.8.9;











/**
 * @title BondingManager
 * @notice Manages bonding, transcoder and rewards/fee accounting related operations of the Livepeer protocol
 */
contract BondingManager is ManagerProxyTarget, IBondingManager {
    using SafeMath for uint256;
    using SortedDoublyLL for SortedDoublyLL.Data;
    using EarningsPool for EarningsPool.Data;
    using EarningsPoolLIP36 for EarningsPool.Data;

    // Constants
    // Occurances are replaced at compile time
    // and computed to a single value if possible by the optimizer
    uint256 constant MAX_FUTURE_ROUND = 2**256 - 1;

    // Time between unbonding and possible withdrawl in rounds
    uint64 public unbondingPeriod;

    // Represents a transcoder's current state
    struct Transcoder {
        uint256 lastRewardRound; // Last round that the transcoder called reward
        uint256 rewardCut; // % of reward paid to transcoder by a delegator
        uint256 feeShare; // % of fees paid to delegators by transcoder
        mapping(uint256 => EarningsPool.Data) earningsPoolPerRound; // Mapping of round => earnings pool for the round
        uint256 lastActiveStakeUpdateRound; // Round for which the stake was last updated while the transcoder is active
        uint256 activationRound; // Round in which the transcoder became active - 0 if inactive
        uint256 deactivationRound; // Round in which the transcoder will become inactive
        uint256 activeCumulativeRewards; // The transcoder's cumulative rewards that are active in the current round
        uint256 cumulativeRewards; // The transcoder's cumulative rewards (earned via the its active staked rewards and its reward cut).
        uint256 cumulativeFees; // The transcoder's cumulative fees (earned via the its active staked rewards and its fee share)
        uint256 lastFeeRound; // Latest round in which the transcoder received fees
    }

    // The various states a transcoder can be in
    enum TranscoderStatus {
        NotRegistered,
        Registered
    }

    // Represents a delegator's current state
    struct Delegator {
        uint256 bondedAmount; // The amount of bonded tokens
        uint256 fees; // The amount of fees collected
        address delegateAddress; // The address delegated to
        uint256 delegatedAmount; // The amount of tokens delegated to the delegator
        uint256 startRound; // The round the delegator transitions to bonded phase and is delegated to someone
        uint256 lastClaimRound; // The last round during which the delegator claimed its earnings
        uint256 nextUnbondingLockId; // ID for the next unbonding lock created
        mapping(uint256 => UnbondingLock) unbondingLocks; // Mapping of unbonding lock ID => unbonding lock
    }

    // The various states a delegator can be in
    enum DelegatorStatus {
        Pending,
        Bonded,
        Unbonded
    }

    // Represents an amount of tokens that are being unbonded
    struct UnbondingLock {
        uint256 amount; // Amount of tokens being unbonded
        uint256 withdrawRound; // Round at which unbonding period is over and tokens can be withdrawn
    }

    // Keep track of the known transcoders and delegators
    mapping(address => Delegator) private delegators;
    mapping(address => Transcoder) private transcoders;

    // The total active stake (sum of the stake of active set members) for the current round
    uint256 public currentRoundTotalActiveStake;
    // The total active stake (sum of the stake of active set members) for the next round
    uint256 public nextRoundTotalActiveStake;

    // The transcoder pool is used to keep track of the transcoders that are eligible for activation.
    // The pool keeps track of the pending active set in round N and the start of round N + 1 transcoders
    // in the pool are locked into the active set for round N + 1
    SortedDoublyLL.Data private transcoderPool;

    // Check if sender is TicketBroker
    modifier onlyTicketBroker() {
        _onlyTicketBroker();
        _;
    }

    // Check if sender is RoundsManager
    modifier onlyRoundsManager() {
        _onlyRoundsManager();
        _;
    }

    // Check if sender is Verifier
    modifier onlyVerifier() {
        _onlyVerifier();
        _;
    }

    // Check if current round is initialized
    modifier currentRoundInitialized() {
        _currentRoundInitialized();
        _;
    }

    // Automatically claim earnings from lastClaimRound through the current round
    modifier autoClaimEarnings(address _delegator) {
        _autoClaimEarnings(_delegator);
        _;
    }

    /**
     * @notice BondingManager constructor. Only invokes constructor of base Manager contract with provided Controller address
     * @dev This constructor will not initialize any state variables besides `controller`. The following setter functions
     * should be used to initialize state variables post-deployment:
     * - setUnbondingPeriod()
     * - setNumActiveTranscoders()
     * - setMaxEarningsClaimsRounds()
     * @param _controller Address of Controller that this contract will be registered with
     */
    constructor(address _controller) Manager(_controller) {}

    /**
     * @notice Set unbonding period. Only callable by Controller owner
     * @param _unbondingPeriod Rounds between unbonding and possible withdrawal
     */
    function setUnbondingPeriod(uint64 _unbondingPeriod) external onlyControllerOwner {
        unbondingPeriod = _unbondingPeriod;

        emit ParameterUpdate("unbondingPeriod");
    }

    /**
     * @notice Set maximum number of active transcoders. Only callable by Controller owner
     * @param _numActiveTranscoders Number of active transcoders
     */
    function setNumActiveTranscoders(uint256 _numActiveTranscoders) external onlyControllerOwner {
        transcoderPool.setMaxSize(_numActiveTranscoders);

        emit ParameterUpdate("numActiveTranscoders");
    }

    /**
     * @notice Sets commission rates as a transcoder and if the caller is not in the transcoder pool tries to add it
     * @dev Percentages are represented as numerators of fractions over MathUtils.PERC_DIVISOR
     * @param _rewardCut % of reward paid to transcoder by a delegator
     * @param _feeShare % of fees paid to delegators by a transcoder
     */
    function transcoder(uint256 _rewardCut, uint256 _feeShare) external {
        transcoderWithHint(_rewardCut, _feeShare, address(0), address(0));
    }

    /**
     * @notice Delegate stake towards a specific address
     * @param _amount The amount of tokens to stake
     * @param _to The address of the transcoder to stake towards
     */
    function bond(uint256 _amount, address _to) external {
        bondWithHint(_amount, _to, address(0), address(0), address(0), address(0));
    }

    /**
     * @notice Unbond an amount of the delegator's bonded stake
     * @param _amount Amount of tokens to unbond
     */
    function unbond(uint256 _amount) external {
        unbondWithHint(_amount, address(0), address(0));
    }

    /**
     * @notice Rebond tokens for an unbonding lock to a delegator's current delegate while a delegator is in the Bonded or Pending status
     * @param _unbondingLockId ID of unbonding lock to rebond with
     */
    function rebond(uint256 _unbondingLockId) external {
        rebondWithHint(_unbondingLockId, address(0), address(0));
    }

    /**
     * @notice Rebond tokens for an unbonding lock to a delegate while a delegator is in the Unbonded status
     * @param _to Address of delegate
     * @param _unbondingLockId ID of unbonding lock to rebond with
     */
    function rebondFromUnbonded(address _to, uint256 _unbondingLockId) external {
        rebondFromUnbondedWithHint(_to, _unbondingLockId, address(0), address(0));
    }

    /**
     * @notice Withdraws tokens for an unbonding lock that has existed through an unbonding period
     * @param _unbondingLockId ID of unbonding lock to withdraw with
     */
    function withdrawStake(uint256 _unbondingLockId) external whenSystemNotPaused currentRoundInitialized {
        Delegator storage del = delegators[msg.sender];
        UnbondingLock storage lock = del.unbondingLocks[_unbondingLockId];

        require(isValidUnbondingLock(msg.sender, _unbondingLockId), "invalid unbonding lock ID");
        require(
            lock.withdrawRound <= roundsManager().currentRound(),
            "withdraw round must be before or equal to the current round"
        );

        uint256 amount = lock.amount;
        uint256 withdrawRound = lock.withdrawRound;
        // Delete unbonding lock
        delete del.unbondingLocks[_unbondingLockId];

        // Tell Minter to transfer stake (LPT) to the delegator
        minter().trustedTransferTokens(msg.sender, amount);

        emit WithdrawStake(msg.sender, _unbondingLockId, amount, withdrawRound);
    }

    /**
     * @notice Withdraws fees to the caller
     */
    function withdrawFees(address payable _recipient, uint256 _amount)
        external
        whenSystemNotPaused
        currentRoundInitialized
        autoClaimEarnings(msg.sender)
    {
        require(_recipient != address(0), "invalid recipient");
        uint256 fees = delegators[msg.sender].fees;
        require(fees >= _amount, "insufficient fees to withdraw");
        delegators[msg.sender].fees = fees.sub(_amount);

        // Tell Minter to transfer fees (ETH) to the address
        minter().trustedWithdrawETH(_recipient, _amount);

        emit WithdrawFees(msg.sender, _recipient, _amount);
    }

    /**
     * @notice Mint token rewards for an active transcoder and its delegators
     */
    function reward() external {
        rewardWithHint(address(0), address(0));
    }

    /**
     * @notice Update transcoder's fee pool. Only callable by the TicketBroker
     * @param _transcoder Transcoder address
     * @param _fees Fees to be added to the fee pool
     */
    function updateTranscoderWithFees(
        address _transcoder,
        uint256 _fees,
        uint256 _round
    ) external whenSystemNotPaused onlyTicketBroker {
        // Silence unused param compiler warning
        _round;

        require(isRegisteredTranscoder(_transcoder), "transcoder must be registered");

        uint256 currentRound = roundsManager().currentRound();

        Transcoder storage t = transcoders[_transcoder];

        uint256 lastRewardRound = t.lastRewardRound;
        uint256 activeCumulativeRewards = t.activeCumulativeRewards;

        // LIP-36: Add fees for the current round instead of '_round'
        // https://github.com/livepeer/LIPs/issues/35#issuecomment-673659199
        EarningsPool.Data storage earningsPool = t.earningsPoolPerRound[currentRound];
        EarningsPool.Data memory prevEarningsPool = latestCumulativeFactorsPool(t, currentRound.sub(1));

        // if transcoder hasn't called 'reward()' for '_round' its 'transcoderFeeShare', 'transcoderRewardCut' and 'totalStake'
        // on the 'EarningsPool' for '_round' would not be initialized and the fee distribution wouldn't happen as expected
        // for cumulative fee calculation this would result in division by zero.
        if (currentRound > lastRewardRound) {
            earningsPool.setCommission(t.rewardCut, t.feeShare);

            uint256 lastUpdateRound = t.lastActiveStakeUpdateRound;
            if (lastUpdateRound < currentRound) {
                earningsPool.setStake(t.earningsPoolPerRound[lastUpdateRound].totalStake);
            }

            // If reward() has not been called yet in the current round, then the transcoder's activeCumulativeRewards has not
            // yet been set in for the round. When the transcoder calls reward() its activeCumulativeRewards will be set to its
            // current cumulativeRewards. So, we can just use the transcoder's cumulativeRewards here because this will become
            // the transcoder's activeCumulativeRewards if it calls reward() later on in the current round
            activeCumulativeRewards = t.cumulativeRewards;
        }

        uint256 totalStake = earningsPool.totalStake;
        if (prevEarningsPool.cumulativeRewardFactor == 0 && lastRewardRound == currentRound) {
            // if transcoder called reward for 'currentRound' but not for 'currentRound - 1' (missed reward call)
            // retroactively calculate what its cumulativeRewardFactor would have been for 'currentRound - 1' (cfr. previous lastRewardRound for transcoder)
            // based on rewards for currentRound
            IMinter mtr = minter();
            uint256 rewards = PreciseMathUtils.percOf(
                mtr.currentMintableTokens().add(mtr.currentMintedTokens()),
                totalStake,
                currentRoundTotalActiveStake
            );
            uint256 transcoderCommissionRewards = MathUtils.percOf(rewards, earningsPool.transcoderRewardCut);
            uint256 delegatorsRewards = rewards.sub(transcoderCommissionRewards);

            prevEarningsPool.cumulativeRewardFactor = PreciseMathUtils.percOf(
                earningsPool.cumulativeRewardFactor,
                totalStake,
                delegatorsRewards.add(totalStake)
            );
        }

        uint256 delegatorsFees = MathUtils.percOf(_fees, earningsPool.transcoderFeeShare);
        uint256 transcoderCommissionFees = _fees.sub(delegatorsFees);
        // Calculate the fees earned by the transcoder's earned rewards
        uint256 transcoderRewardStakeFees = PreciseMathUtils.percOf(
            delegatorsFees,
            activeCumulativeRewards,
            totalStake
        );
        // Track fees earned by the transcoder based on its earned rewards and feeShare
        t.cumulativeFees = t.cumulativeFees.add(transcoderRewardStakeFees).add(transcoderCommissionFees);
        // Update cumulative fee factor with new fees
        // The cumulativeFeeFactor is used to calculate fees for all delegators including the transcoder (self-delegated)
        // Note that delegatorsFees includes transcoderRewardStakeFees, but no delegator will claim that amount using
        // the earnings claiming algorithm and instead that amount is accounted for in the transcoder's cumulativeFees field
        earningsPool.updateCumulativeFeeFactor(prevEarningsPool, delegatorsFees);

        t.lastFeeRound = currentRound;
    }

    /**
     * @notice Slash a transcoder. Only callable by the Verifier
     * @param _transcoder Transcoder address
     * @param _finder Finder that proved a transcoder violated a slashing condition. Null address if there is no finder
     * @param _slashAmount Percentage of transcoder bond to be slashed
     * @param _finderFee Percentage of penalty awarded to finder. Zero if there is no finder
     */
    function slashTranscoder(
        address _transcoder,
        address _finder,
        uint256 _slashAmount,
        uint256 _finderFee
    ) external whenSystemNotPaused onlyVerifier {
        Delegator storage del = delegators[_transcoder];

        if (del.bondedAmount > 0) {
            uint256 penalty = MathUtils.percOf(delegators[_transcoder].bondedAmount, _slashAmount);

            // If active transcoder, resign it
            if (transcoderPool.contains(_transcoder)) {
                resignTranscoder(_transcoder);
            }

            // Decrease bonded stake
            del.bondedAmount = del.bondedAmount.sub(penalty);

            // If still bonded decrease delegate's delegated amount
            if (delegatorStatus(_transcoder) == DelegatorStatus.Bonded) {
                delegators[del.delegateAddress].delegatedAmount = delegators[del.delegateAddress].delegatedAmount.sub(
                    penalty
                );
            }

            // Account for penalty
            uint256 burnAmount = penalty;

            // Award finder fee if there is a finder address
            if (_finder != address(0)) {
                uint256 finderAmount = MathUtils.percOf(penalty, _finderFee);
                minter().trustedTransferTokens(_finder, finderAmount);

                // Minter burns the slashed funds - finder reward
                minter().trustedBurnTokens(burnAmount.sub(finderAmount));

                emit TranscoderSlashed(_transcoder, _finder, penalty, finderAmount);
            } else {
                // Minter burns the slashed funds
                minter().trustedBurnTokens(burnAmount);

                emit TranscoderSlashed(_transcoder, address(0), penalty, 0);
            }
        } else {
            emit TranscoderSlashed(_transcoder, _finder, 0, 0);
        }
    }

    /**
     * @notice Claim token pools shares for a delegator from its lastClaimRound through the end round
     * @param _endRound The last round for which to claim token pools shares for a delegator
     */
    function claimEarnings(uint256 _endRound) external whenSystemNotPaused currentRoundInitialized {
        // Silence unused param compiler warning
        _endRound;

        _autoClaimEarnings(msg.sender);
    }

    /**
     * @notice Called during round initialization to set the total active stake for the round. Only callable by the RoundsManager
     */
    function setCurrentRoundTotalActiveStake() external onlyRoundsManager {
        currentRoundTotalActiveStake = nextRoundTotalActiveStake;
    }

    /**
     * @notice Sets commission rates as a transcoder and if the caller is not in the transcoder pool tries to add it using an optional list hint
     * @dev Percentages are represented as numerators of fractions over MathUtils.PERC_DIVISOR. If the caller is going to be added to the pool, the
     * caller can provide an optional hint for the insertion position in the pool via the `_newPosPrev` and `_newPosNext` params. A linear search will
     * be executed starting at the hint to find the correct position - in the best case, the hint is the correct position so no search is executed.
     * See SortedDoublyLL.sol for details on list hints
     * @param _rewardCut % of reward paid to transcoder by a delegator
     * @param _feeShare % of fees paid to delegators by a transcoder
     * @param _newPosPrev Address of previous transcoder in pool if the caller joins the pool
     * @param _newPosNext Address of next transcoder in pool if the caller joins the pool
     */
    function transcoderWithHint(
        uint256 _rewardCut,
        uint256 _feeShare,
        address _newPosPrev,
        address _newPosNext
    ) public whenSystemNotPaused currentRoundInitialized {
        require(!roundsManager().currentRoundLocked(), "can't update transcoder params, current round is locked");
        require(MathUtils.validPerc(_rewardCut), "invalid rewardCut percentage");
        require(MathUtils.validPerc(_feeShare), "invalid feeShare percentage");
        require(isRegisteredTranscoder(msg.sender), "transcoder must be registered");

        Transcoder storage t = transcoders[msg.sender];
        uint256 currentRound = roundsManager().currentRound();

        require(
            !isActiveTranscoder(msg.sender) || t.lastRewardRound == currentRound,
            "caller can't be active or must have already called reward for the current round"
        );

        t.rewardCut = _rewardCut;
        t.feeShare = _feeShare;

        if (!transcoderPool.contains(msg.sender)) {
            tryToJoinActiveSet(
                msg.sender,
                delegators[msg.sender].delegatedAmount,
                currentRound.add(1),
                _newPosPrev,
                _newPosNext
            );
        }

        emit TranscoderUpdate(msg.sender, _rewardCut, _feeShare);
    }

    /**
     * @notice Delegates stake "on behalf of" another address towards a specific address
     * and updates the transcoder pool using optional list hints if needed
     * @dev If the caller is decreasing the stake of its old delegate in the transcoder pool, the caller can provide an optional hint
     * for the insertion position of the old delegate via the `_oldDelegateNewPosPrev` and `_oldDelegateNewPosNext` params.
     * If the caller is delegating to a delegate that is in the transcoder pool, the caller can provide an optional hint for the
     * insertion position of the delegate via the `_currDelegateNewPosPrev` and `_currDelegateNewPosNext` params.
     * In both cases, a linear search will be executed starting at the hint to find the correct position. In the best case, the hint
     * is the correct position so no search is executed. See SortedDoublyLL.sol for details on list hints
     * @param _amount The amount of tokens to stake.
     * @param _owner The address of the owner of the bond
     * @param _to The address of the transcoder to stake towards
     * @param _oldDelegateNewPosPrev The address of the previous transcoder in the pool for the old delegate
     * @param _oldDelegateNewPosNext The address of the next transcoder in the pool for the old delegate
     * @param _currDelegateNewPosPrev The address of the previous transcoder in the pool for the current delegate
     * @param _currDelegateNewPosNext The address of the next transcoder in the pool for the current delegate
     */
    function bondForWithHint(
        uint256 _amount,
        address _owner,
        address _to,
        address _oldDelegateNewPosPrev,
        address _oldDelegateNewPosNext,
        address _currDelegateNewPosPrev,
        address _currDelegateNewPosNext
    ) public whenSystemNotPaused currentRoundInitialized {
        // the `autoClaimEarnings` modifier has been replaced with its internal function as a `Stack too deep` error work-around
        _autoClaimEarnings(_owner);
        Delegator storage del = delegators[_owner];

        uint256 currentRound = roundsManager().currentRound();
        // Amount to delegate
        uint256 delegationAmount = _amount;
        // Current delegate
        address currentDelegate = del.delegateAddress;
        // Current bonded amount
        uint256 currentBondedAmount = del.bondedAmount;

        if (delegatorStatus(_owner) == DelegatorStatus.Unbonded) {
            // New delegate
            // Set start round
            // Don't set start round if delegator is in pending state because the start round would not change
            del.startRound = currentRound.add(1);
            // Unbonded state = no existing delegate and no bonded stake
            // Thus, delegation amount = provided amount
        } else if (currentBondedAmount > 0 && currentDelegate != _to) {
            // Prevents third-party caller to change the delegate of a delegator
            require(msg.sender == _owner || msg.sender == l2Migrator(), "INVALID_CALLER");
            // A registered transcoder cannot delegate its bonded stake toward another address
            // because it can only be delegated toward itself
            // In the future, if delegation towards another registered transcoder as an already
            // registered transcoder becomes useful (i.e. for transitive delegation), this restriction
            // could be removed
            require(!isRegisteredTranscoder(_owner), "registered transcoders can't delegate towards other addresses");
            // Changing delegate
            // Set start round
            del.startRound = currentRound.add(1);
            // Update amount to delegate with previous delegation amount
            delegationAmount = delegationAmount.add(currentBondedAmount);

            decreaseTotalStake(currentDelegate, currentBondedAmount, _oldDelegateNewPosPrev, _oldDelegateNewPosNext);
        }

        {
            Transcoder storage newDelegate = transcoders[_to];
            EarningsPool.Data storage currPool = newDelegate.earningsPoolPerRound[currentRound];
            if (currPool.cumulativeRewardFactor == 0) {
                currPool.cumulativeRewardFactor = cumulativeFactorsPool(newDelegate, newDelegate.lastRewardRound)
                    .cumulativeRewardFactor;
            }
            if (currPool.cumulativeFeeFactor == 0) {
                currPool.cumulativeFeeFactor = cumulativeFactorsPool(newDelegate, newDelegate.lastFeeRound)
                    .cumulativeFeeFactor;
            }
        }

        // cannot delegate to someone without having bonded stake
        require(delegationAmount > 0, "delegation amount must be greater than 0");
        // Update delegate
        del.delegateAddress = _to;
        // Update bonded amount
        del.bondedAmount = currentBondedAmount.add(_amount);

        increaseTotalStake(_to, delegationAmount, _currDelegateNewPosPrev, _currDelegateNewPosNext);

        if (_amount > 0) {
            // Transfer the LPT to the Minter
            livepeerToken().transferFrom(msg.sender, address(minter()), _amount);
        }

        emit Bond(_to, currentDelegate, _owner, _amount, del.bondedAmount);
    }

    /**
     * @notice Delegates stake towards a specific address and updates the transcoder pool using optional list hints if needed
     * @dev If the caller is decreasing the stake of its old delegate in the transcoder pool, the caller can provide an optional hint
     * for the insertion position of the old delegate via the `_oldDelegateNewPosPrev` and `_oldDelegateNewPosNext` params.
     * If the caller is delegating to a delegate that is in the transcoder pool, the caller can provide an optional hint for the
     * insertion position of the delegate via the `_currDelegateNewPosPrev` and `_currDelegateNewPosNext` params.
     * In both cases, a linear search will be executed starting at the hint to find the correct position. In the best case, the hint
     * is the correct position so no search is executed. See SortedDoublyLL.sol for details on list hints
     * @param _amount The amount of tokens to stake.
     * @param _to The address of the transcoder to stake towards
     * @param _oldDelegateNewPosPrev The address of the previous transcoder in the pool for the old delegate
     * @param _oldDelegateNewPosNext The address of the next transcoder in the pool for the old delegate
     * @param _currDelegateNewPosPrev The address of the previous transcoder in the pool for the current delegate
     * @param _currDelegateNewPosNext The address of the next transcoder in the pool for the current delegate
     */
    function bondWithHint(
        uint256 _amount,
        address _to,
        address _oldDelegateNewPosPrev,
        address _oldDelegateNewPosNext,
        address _currDelegateNewPosPrev,
        address _currDelegateNewPosNext
    ) public {
        bondForWithHint(
            _amount,
            msg.sender,
            _to,
            _oldDelegateNewPosPrev,
            _oldDelegateNewPosNext,
            _currDelegateNewPosPrev,
            _currDelegateNewPosNext
        );
    }

    /**
     * @notice Transfers ownership of a bond to a new delegator using optional hints if needed
     *
     * If the receiver is already bonded to a different delegate than the bond owner then the stake goes
     * to the receiver's delegate otherwise the receiver's delegate is set as the owner's delegate
     *
     * @dev If the original delegate is in the transcoder pool, the caller can provide an optional hint for the
     * insertion position of the delegate via the `_oldDelegateNewPosPrev` and `_oldDelegateNewPosNext` params.
     * If the target delegate is in the transcoder pool, the caller can provide an optional hint for the
     * insertion position of the delegate via the `_newDelegateNewPosPrev` and `_newDelegateNewPosNext` params.
     *
     * In both cases, a linear search will be executed starting at the hint to find the correct position. In the best case, the hint
     * is the correct position so no search is executed. See SortedDoublyLL.sol for details on list hints
     * @param _delegator Receiver of the bond
     * @param _amount Portion of the bond to transfer to receiver
     * @param _oldDelegateNewPosPrev Address of previous transcoder in pool if the delegate remains in the pool
     * @param _oldDelegateNewPosNext Address of next transcoder in pool if the delegate remains in the pool
     * @param _newDelegateNewPosPrev Address of previous transcoder in pool if the delegate is in the pool
     * @param _newDelegateNewPosNext Address of next transcoder in pool if the delegate is in the pool
     */
    function transferBond(
        address _delegator,
        uint256 _amount,
        address _oldDelegateNewPosPrev,
        address _oldDelegateNewPosNext,
        address _newDelegateNewPosPrev,
        address _newDelegateNewPosNext
    ) public whenSystemNotPaused currentRoundInitialized {
        // the `autoClaimEarnings` modifier has been replaced with its internal function as a `Stack too deep` error work-around
        _autoClaimEarnings(msg.sender);
        Delegator storage oldDel = delegators[msg.sender];
        // Cache delegate address of caller before unbondWithHint because
        // if unbondWithHint is for a full unbond the caller's delegate address will be set to null
        address oldDelDelegate = oldDel.delegateAddress;

        unbondWithHint(_amount, _oldDelegateNewPosPrev, _oldDelegateNewPosNext);

        Delegator storage newDel = delegators[_delegator];

        uint256 oldDelUnbondingLockId = oldDel.nextUnbondingLockId.sub(1);
        uint256 withdrawRound = oldDel.unbondingLocks[oldDelUnbondingLockId].withdrawRound;

        // Burn lock for current owner
        delete oldDel.unbondingLocks[oldDelUnbondingLockId];

        // Create lock for new owner
        uint256 newDelUnbondingLockId = newDel.nextUnbondingLockId;

        newDel.unbondingLocks[newDelUnbondingLockId] = UnbondingLock({ amount: _amount, withdrawRound: withdrawRound });
        newDel.nextUnbondingLockId = newDel.nextUnbondingLockId.add(1);

        emit TransferBond(msg.sender, _delegator, oldDelUnbondingLockId, newDelUnbondingLockId, _amount);

        // Claim earnings for receiver before processing unbonding lock
        uint256 currentRound = roundsManager().currentRound();
        uint256 lastClaimRound = newDel.lastClaimRound;
        if (lastClaimRound < currentRound) {
            updateDelegatorWithEarnings(_delegator, currentRound, lastClaimRound);
        }

        // Rebond lock for new owner
        if (newDel.delegateAddress == address(0) && newDel.bondedAmount == 0) {
            newDel.delegateAddress = oldDelDelegate;
        }

        // Move to Pending state if receiver is currently in Unbonded state
        if (delegatorStatus(_delegator) == DelegatorStatus.Unbonded) {
            newDel.startRound = currentRound.add(1);
        }

        // Process rebond using unbonding lock
        processRebond(_delegator, newDelUnbondingLockId, _newDelegateNewPosPrev, _newDelegateNewPosNext);
    }

    /**
     * @notice Unbond an amount of the delegator's bonded stake and updates the transcoder pool using an optional list hint if needed
     * @dev If the caller remains in the transcoder pool, the caller can provide an optional hint for its insertion position in the
     * pool via the `_newPosPrev` and `_newPosNext` params. A linear search will be executed starting at the hint to find the correct position.
     * In the best case, the hint is the correct position so no search is executed. See SortedDoublyLL.sol details on list hints
     * @param _amount Amount of tokens to unbond
     * @param _newPosPrev Address of previous transcoder in pool if the caller remains in the pool
     * @param _newPosNext Address of next transcoder in pool if the caller remains in the pool
     */
    function unbondWithHint(
        uint256 _amount,
        address _newPosPrev,
        address _newPosNext
    ) public whenSystemNotPaused currentRoundInitialized autoClaimEarnings(msg.sender) {
        require(delegatorStatus(msg.sender) == DelegatorStatus.Bonded, "caller must be bonded");

        Delegator storage del = delegators[msg.sender];

        require(_amount > 0, "unbond amount must be greater than 0");
        require(_amount <= del.bondedAmount, "amount is greater than bonded amount");

        address currentDelegate = del.delegateAddress;
        uint256 currentRound = roundsManager().currentRound();
        uint256 withdrawRound = currentRound.add(unbondingPeriod);
        uint256 unbondingLockId = del.nextUnbondingLockId;

        // Create new unbonding lock
        del.unbondingLocks[unbondingLockId] = UnbondingLock({ amount: _amount, withdrawRound: withdrawRound });
        // Increment ID for next unbonding lock
        del.nextUnbondingLockId = unbondingLockId.add(1);
        // Decrease delegator's bonded amount
        del.bondedAmount = del.bondedAmount.sub(_amount);

        if (del.bondedAmount == 0) {
            // Delegator no longer delegated to anyone if it does not have a bonded amount
            del.delegateAddress = address(0);
            // Delegator does not have a start round if it is no longer delegated to anyone
            del.startRound = 0;

            if (transcoderPool.contains(msg.sender)) {
                resignTranscoder(msg.sender);
            }
        }

        // If msg.sender was resigned this statement will only decrease delegators[currentDelegate].delegatedAmount
        decreaseTotalStake(currentDelegate, _amount, _newPosPrev, _newPosNext);

        emit Unbond(currentDelegate, msg.sender, unbondingLockId, _amount, withdrawRound);
    }

    /**
     * @notice Rebond tokens for an unbonding lock to a delegator's current delegate while a delegator is in the Bonded or Pending status and updates
     * the transcoder pool using an optional list hint if needed
     * @dev If the delegate is in the transcoder pool, the caller can provide an optional hint for the delegate's insertion position in the
     * pool via the `_newPosPrev` and `_newPosNext` params. A linear search will be executed starting at the hint to find the correct position.
     * In the best case, the hint is the correct position so no search is executed. See SortedDoublyLL.sol details on list hints
     * @param _unbondingLockId ID of unbonding lock to rebond with
     * @param _newPosPrev Address of previous transcoder in pool if the delegate is in the pool
     * @param _newPosNext Address of next transcoder in pool if the delegate is in the pool
     */
    function rebondWithHint(
        uint256 _unbondingLockId,
        address _newPosPrev,
        address _newPosNext
    ) public whenSystemNotPaused currentRoundInitialized autoClaimEarnings(msg.sender) {
        require(delegatorStatus(msg.sender) != DelegatorStatus.Unbonded, "caller must be bonded");

        // Process rebond using unbonding lock
        processRebond(msg.sender, _unbondingLockId, _newPosPrev, _newPosNext);
    }

    /**
     * @notice Rebond tokens for an unbonding lock to a delegate while a delegator is in the Unbonded status and updates the transcoder pool using
     * an optional list hint if needed
     * @dev If the delegate joins the transcoder pool, the caller can provide an optional hint for the delegate's insertion position in the
     * pool via the `_newPosPrev` and `_newPosNext` params. A linear search will be executed starting at the hint to find the correct position.
     * In the best case, the hint is the correct position so no search is executed. See SortedDoublyLL.sol for details on list hints
     * @param _to Address of delegate
     * @param _unbondingLockId ID of unbonding lock to rebond with
     * @param _newPosPrev Address of previous transcoder in pool if the delegate joins the pool
     * @param _newPosNext Address of next transcoder in pool if the delegate joins the pool
     */
    function rebondFromUnbondedWithHint(
        address _to,
        uint256 _unbondingLockId,
        address _newPosPrev,
        address _newPosNext
    ) public whenSystemNotPaused currentRoundInitialized autoClaimEarnings(msg.sender) {
        require(delegatorStatus(msg.sender) == DelegatorStatus.Unbonded, "caller must be unbonded");

        // Set delegator's start round and transition into Pending state
        delegators[msg.sender].startRound = roundsManager().currentRound().add(1);
        // Set delegator's delegate
        delegators[msg.sender].delegateAddress = _to;
        // Process rebond using unbonding lock
        processRebond(msg.sender, _unbondingLockId, _newPosPrev, _newPosNext);
    }

    /**
     * @notice Mint token rewards for an active transcoder and its delegators and update the transcoder pool using an optional list hint if needed
     * @dev If the caller is in the transcoder pool, the caller can provide an optional hint for its insertion position in the
     * pool via the `_newPosPrev` and `_newPosNext` params. A linear search will be executed starting at the hint to find the correct position.
     * In the best case, the hint is the correct position so no search is executed. See SortedDoublyLL.sol for details on list hints
     * @param _newPosPrev Address of previous transcoder in pool if the caller is in the pool
     * @param _newPosNext Address of next transcoder in pool if the caller is in the pool
     */
    function rewardWithHint(address _newPosPrev, address _newPosNext)
        public
        whenSystemNotPaused
        currentRoundInitialized
    {
        uint256 currentRound = roundsManager().currentRound();

        require(isActiveTranscoder(msg.sender), "caller must be an active transcoder");
        require(
            transcoders[msg.sender].lastRewardRound != currentRound,
            "caller has already called reward for the current round"
        );

        Transcoder storage t = transcoders[msg.sender];
        EarningsPool.Data storage earningsPool = t.earningsPoolPerRound[currentRound];

        // Set last round that transcoder called reward
        earningsPool.setCommission(t.rewardCut, t.feeShare);

        // If transcoder didn't receive stake updates during the previous round and hasn't called reward for > 1 round
        // the 'totalStake' on its 'EarningsPool' for the current round wouldn't be initialized
        // Thus we sync the the transcoder's stake to when it was last updated
        // 'updateTrancoderWithRewards()' will set the update round to 'currentRound +1' so this synchronization shouldn't occur frequently
        uint256 lastUpdateRound = t.lastActiveStakeUpdateRound;
        if (lastUpdateRound < currentRound) {
            earningsPool.setStake(t.earningsPoolPerRound[lastUpdateRound].totalStake);
        }

        // Create reward based on active transcoder's stake relative to the total active stake
        // rewardTokens = (current mintable tokens for the round * active transcoder stake) / total active stake
        uint256 rewardTokens = minter().createReward(earningsPool.totalStake, currentRoundTotalActiveStake);

        updateTranscoderWithRewards(msg.sender, rewardTokens, currentRound, _newPosPrev, _newPosNext);

        // Set last round that transcoder called reward
        t.lastRewardRound = currentRound;

        emit Reward(msg.sender, rewardTokens);
    }

    /**
     * @notice Returns pending bonded stake for a delegator from its lastClaimRound through an end round
     * @param _delegator Address of delegator
     * @param _endRound The last round to compute pending stake from
     * @return Pending bonded stake for '_delegator' since last claiming rewards
     */
    function pendingStake(address _delegator, uint256 _endRound) public view returns (uint256) {
        // Silence unused param compiler warning
        _endRound;

        uint256 endRound = roundsManager().currentRound();
        (uint256 stake, ) = pendingStakeAndFees(_delegator, endRound);
        return stake;
    }

    /**
     * @notice Returns pending fees for a delegator from its lastClaimRound through an end round
     * @param _delegator Address of delegator
     * @param _endRound The last round to compute pending fees from
     * @return Pending fees for '_delegator' since last claiming fees
     */
    function pendingFees(address _delegator, uint256 _endRound) public view returns (uint256) {
        // Silence unused param compiler warning
        _endRound;

        uint256 endRound = roundsManager().currentRound();
        (, uint256 fees) = pendingStakeAndFees(_delegator, endRound);
        return fees;
    }

    /**
     * @notice Returns total bonded stake for a transcoder
     * @param _transcoder Address of transcoder
     * @return total bonded stake for a delegator
     */
    function transcoderTotalStake(address _transcoder) public view returns (uint256) {
        return delegators[_transcoder].delegatedAmount;
    }

    /**
     * @notice Computes transcoder status
     * @param _transcoder Address of transcoder
     * @return registered or not registered transcoder status
     */
    function transcoderStatus(address _transcoder) public view returns (TranscoderStatus) {
        if (isRegisteredTranscoder(_transcoder)) return TranscoderStatus.Registered;
        return TranscoderStatus.NotRegistered;
    }

    /**
     * @notice Computes delegator status
     * @param _delegator Address of delegator
     * @return bonded, unbonded or pending delegator status
     */
    function delegatorStatus(address _delegator) public view returns (DelegatorStatus) {
        Delegator storage del = delegators[_delegator];

        if (del.bondedAmount == 0) {
            // Delegator unbonded all its tokens
            return DelegatorStatus.Unbonded;
        } else if (del.startRound > roundsManager().currentRound()) {
            // Delegator round start is in the future
            return DelegatorStatus.Pending;
        } else {
            // Delegator round start is now or in the past
            // del.startRound != 0 here because if del.startRound = 0 then del.bondedAmount = 0 which
            // would trigger the first if clause
            return DelegatorStatus.Bonded;
        }
    }

    /**
     * @notice Return transcoder information
     * @param _transcoder Address of transcoder
     * @return lastRewardRound Trancoder's last reward round
     * @return rewardCut Transcoder's reward cut
     * @return feeShare Transcoder's fee share
     * @return lastActiveStakeUpdateRound Round in which transcoder's stake was last updated while active
     * @return activationRound Round in which transcoder became active
     * @return deactivationRound Round in which transcoder will no longer be active
     * @return activeCumulativeRewards Transcoder's cumulative rewards that are currently active
     * @return cumulativeRewards Transcoder's cumulative rewards (earned via its active staked rewards and its reward cut)
     * @return cumulativeFees Transcoder's cumulative fees (earned via its active staked rewards and its fee share)
     * @return lastFeeRound Latest round that the transcoder received fees
     */
    function getTranscoder(address _transcoder)
        public
        view
        returns (
            uint256 lastRewardRound,
            uint256 rewardCut,
            uint256 feeShare,
            uint256 lastActiveStakeUpdateRound,
            uint256 activationRound,
            uint256 deactivationRound,
            uint256 activeCumulativeRewards,
            uint256 cumulativeRewards,
            uint256 cumulativeFees,
            uint256 lastFeeRound
        )
    {
        Transcoder storage t = transcoders[_transcoder];

        lastRewardRound = t.lastRewardRound;
        rewardCut = t.rewardCut;
        feeShare = t.feeShare;
        lastActiveStakeUpdateRound = t.lastActiveStakeUpdateRound;
        activationRound = t.activationRound;
        deactivationRound = t.deactivationRound;
        activeCumulativeRewards = t.activeCumulativeRewards;
        cumulativeRewards = t.cumulativeRewards;
        cumulativeFees = t.cumulativeFees;
        lastFeeRound = t.lastFeeRound;
    }

    /**
     * @notice Return transcoder's earnings pool for a given round
     * @param _transcoder Address of transcoder
     * @param _round Round number
     * @return totalStake Transcoder's total stake in '_round'
     * @return transcoderRewardCut Transcoder's reward cut for '_round'
     * @return transcoderFeeShare Transcoder's fee share for '_round'
     * @return cumulativeRewardFactor The cumulative reward factor for delegator rewards calculation (only used after LIP-36)
     * @return cumulativeFeeFactor The cumulative fee factor for delegator fees calculation (only used after LIP-36)
     */
    function getTranscoderEarningsPoolForRound(address _transcoder, uint256 _round)
        public
        view
        returns (
            uint256 totalStake,
            uint256 transcoderRewardCut,
            uint256 transcoderFeeShare,
            uint256 cumulativeRewardFactor,
            uint256 cumulativeFeeFactor
        )
    {
        EarningsPool.Data storage earningsPool = transcoders[_transcoder].earningsPoolPerRound[_round];

        totalStake = earningsPool.totalStake;
        transcoderRewardCut = earningsPool.transcoderRewardCut;
        transcoderFeeShare = earningsPool.transcoderFeeShare;
        cumulativeRewardFactor = earningsPool.cumulativeRewardFactor;
        cumulativeFeeFactor = earningsPool.cumulativeFeeFactor;
    }

    /**
     * @notice Return delegator info
     * @param _delegator Address of delegator
     * @return bondedAmount total amount bonded by '_delegator'
     * @return fees amount of fees collected by '_delegator'
     * @return delegateAddress address '_delegator' has bonded to
     * @return delegatedAmount total amount delegated to '_delegator'
     * @return startRound round in which bond for '_delegator' became effective
     * @return lastClaimRound round for which '_delegator' has last claimed earnings
     * @return nextUnbondingLockId ID for the next unbonding lock created for '_delegator'
     */
    function getDelegator(address _delegator)
        public
        view
        returns (
            uint256 bondedAmount,
            uint256 fees,
            address delegateAddress,
            uint256 delegatedAmount,
            uint256 startRound,
            uint256 lastClaimRound,
            uint256 nextUnbondingLockId
        )
    {
        Delegator storage del = delegators[_delegator];

        bondedAmount = del.bondedAmount;
        fees = del.fees;
        delegateAddress = del.delegateAddress;
        delegatedAmount = del.delegatedAmount;
        startRound = del.startRound;
        lastClaimRound = del.lastClaimRound;
        nextUnbondingLockId = del.nextUnbondingLockId;
    }

    /**
     * @notice Return delegator's unbonding lock info
     * @param _delegator Address of delegator
     * @param _unbondingLockId ID of unbonding lock
     * @return amount of stake locked up by unbonding lock
     * @return withdrawRound round in which 'amount' becomes available for withdrawal
     */
    function getDelegatorUnbondingLock(address _delegator, uint256 _unbondingLockId)
        public
        view
        returns (uint256 amount, uint256 withdrawRound)
    {
        UnbondingLock storage lock = delegators[_delegator].unbondingLocks[_unbondingLockId];

        return (lock.amount, lock.withdrawRound);
    }

    /**
     * @notice Returns max size of transcoder pool
     * @return transcoder pool max size
     */
    function getTranscoderPoolMaxSize() public view returns (uint256) {
        return transcoderPool.getMaxSize();
    }

    /**
     * @notice Returns size of transcoder pool
     * @return transcoder pool current size
     */
    function getTranscoderPoolSize() public view returns (uint256) {
        return transcoderPool.getSize();
    }

    /**
     * @notice Returns transcoder with most stake in pool
     * @return address for transcoder with highest stake in transcoder pool
     */
    function getFirstTranscoderInPool() public view returns (address) {
        return transcoderPool.getFirst();
    }

    /**
     * @notice Returns next transcoder in pool for a given transcoder
     * @param _transcoder Address of a transcoder in the pool
     * @return address for the transcoder after '_transcoder' in transcoder pool
     */
    function getNextTranscoderInPool(address _transcoder) public view returns (address) {
        return transcoderPool.getNext(_transcoder);
    }

    /**
     * @notice Return total bonded tokens
     * @return total active stake for the current round
     */
    function getTotalBonded() public view returns (uint256) {
        return currentRoundTotalActiveStake;
    }

    /**
     * @notice Return whether a transcoder is active for the current round
     * @param _transcoder Transcoder address
     * @return true if transcoder is active
     */
    function isActiveTranscoder(address _transcoder) public view returns (bool) {
        Transcoder storage t = transcoders[_transcoder];
        uint256 currentRound = roundsManager().currentRound();
        return t.activationRound <= currentRound && currentRound < t.deactivationRound;
    }

    /**
     * @notice Return whether a transcoder is registered
     * @param _transcoder Transcoder address
     * @return true if transcoder is self-bonded
     */
    function isRegisteredTranscoder(address _transcoder) public view returns (bool) {
        Delegator storage d = delegators[_transcoder];
        return d.delegateAddress == _transcoder && d.bondedAmount > 0;
    }

    /**
     * @notice Return whether an unbonding lock for a delegator is valid
     * @param _delegator Address of delegator
     * @param _unbondingLockId ID of unbonding lock
     * @return true if unbondingLock for ID has a non-zero withdraw round
     */
    function isValidUnbondingLock(address _delegator, uint256 _unbondingLockId) public view returns (bool) {
        // A unbonding lock is only valid if it has a non-zero withdraw round (the default value is zero)
        return delegators[_delegator].unbondingLocks[_unbondingLockId].withdrawRound > 0;
    }

    /**
     * @notice Return an EarningsPool.Data struct with cumulative factors for a given round that are rescaled if needed
     * @param _transcoder Storage pointer to a transcoder struct
     * @param _round The round to fetch the cumulative factors for
     */
    function cumulativeFactorsPool(Transcoder storage _transcoder, uint256 _round)
        internal
        view
        returns (EarningsPool.Data memory pool)
    {
        pool.cumulativeRewardFactor = _transcoder.earningsPoolPerRound[_round].cumulativeRewardFactor;
        pool.cumulativeFeeFactor = _transcoder.earningsPoolPerRound[_round].cumulativeFeeFactor;

        return pool;
    }

    /**
     * @notice Return an EarningsPool.Data struct with the latest cumulative factors for a given round
     * @param _transcoder Storage pointer to a transcoder struct
     * @param _round The round to fetch the latest cumulative factors for
     * @return pool An EarningsPool.Data populated with the latest cumulative factors for _round
     */
    function latestCumulativeFactorsPool(Transcoder storage _transcoder, uint256 _round)
        internal
        view
        returns (EarningsPool.Data memory pool)
    {
        pool = cumulativeFactorsPool(_transcoder, _round);

        uint256 lastRewardRound = _transcoder.lastRewardRound;
        // Only use the cumulativeRewardFactor for lastRewardRound if lastRewardRound is before _round
        if (pool.cumulativeRewardFactor == 0 && lastRewardRound < _round) {
            pool.cumulativeRewardFactor = cumulativeFactorsPool(_transcoder, lastRewardRound).cumulativeRewardFactor;
        }

        uint256 lastFeeRound = _transcoder.lastFeeRound;
        // Only use the cumulativeFeeFactor for lastFeeRound if lastFeeRound is before _round
        if (pool.cumulativeFeeFactor == 0 && lastFeeRound < _round) {
            pool.cumulativeFeeFactor = cumulativeFactorsPool(_transcoder, lastFeeRound).cumulativeFeeFactor;
        }

        return pool;
    }

    /**
     * @notice Return a delegator's cumulative stake and fees using the LIP-36 earnings claiming algorithm
     * @param _transcoder Storage pointer to a transcoder struct for a delegator's delegate
     * @param _startRound The round for the start cumulative factors
     * @param _endRound The round for the end cumulative factors
     * @param _stake The delegator's initial stake before including earned rewards
     * @param _fees The delegator's initial fees before including earned fees
     * @return cStake , cFees where cStake is the delegator's cumulative stake including earned rewards and cFees is the delegator's cumulative fees including earned fees
     */
    function delegatorCumulativeStakeAndFees(
        Transcoder storage _transcoder,
        uint256 _startRound,
        uint256 _endRound,
        uint256 _stake,
        uint256 _fees
    ) internal view returns (uint256 cStake, uint256 cFees) {
        // Fetch start cumulative factors
        EarningsPool.Data memory startPool = cumulativeFactorsPool(_transcoder, _startRound);

        // If the start cumulativeRewardFactor is 0 set the default value to PreciseMathUtils.percPoints(1, 1)
        if (startPool.cumulativeRewardFactor == 0) {
            startPool.cumulativeRewardFactor = PreciseMathUtils.percPoints(1, 1);
        }

        // Fetch end cumulative factors
        EarningsPool.Data memory endPool = latestCumulativeFactorsPool(_transcoder, _endRound);

        // If the end cumulativeRewardFactor is 0 set the default value to PreciseMathUtils.percPoints(1, 1)
        if (endPool.cumulativeRewardFactor == 0) {
            endPool.cumulativeRewardFactor = PreciseMathUtils.percPoints(1, 1);
        }

        cFees = _fees.add(
            PreciseMathUtils.percOf(
                _stake,
                endPool.cumulativeFeeFactor.sub(startPool.cumulativeFeeFactor),
                startPool.cumulativeRewardFactor
            )
        );

        cStake = PreciseMathUtils.percOf(_stake, endPool.cumulativeRewardFactor, startPool.cumulativeRewardFactor);

        return (cStake, cFees);
    }

    /**
     * @notice Return the pending stake and fees for a delegator
     * @param _delegator Address of a delegator
     * @param _endRound The last round to claim earnings for when calculating the pending stake and fees
     * @return stake , fees where stake is the delegator's pending stake and fees is the delegator's pending fees
     */
    function pendingStakeAndFees(address _delegator, uint256 _endRound)
        internal
        view
        returns (uint256 stake, uint256 fees)
    {
        Delegator storage del = delegators[_delegator];
        Transcoder storage t = transcoders[del.delegateAddress];

        fees = del.fees;
        stake = del.bondedAmount;

        uint256 startRound = del.lastClaimRound.add(1);
        address delegateAddr = del.delegateAddress;
        bool isTranscoder = _delegator == delegateAddr;

        // Make sure there is a round to claim i.e. end round - (start round - 1) > 0
        if (startRound <= _endRound) {
            (stake, fees) = delegatorCumulativeStakeAndFees(t, startRound.sub(1), _endRound, stake, fees);
        }
        // cumulativeRewards and cumulativeFees will track *all* rewards/fees earned by the transcoder
        // so it is important that this is only executed with the end round as the current round or else
        // the returned stake and fees will reflect rewards/fees earned in the future relative to the end round
        if (isTranscoder) {
            stake = stake.add(t.cumulativeRewards);
            fees = fees.add(t.cumulativeFees);
        }

        return (stake, fees);
    }

    /**
     * @dev Increase the total stake for a delegate and updates its 'lastActiveStakeUpdateRound'
     * @param _delegate The delegate to increase the stake for
     * @param _amount The amount to increase the stake for '_delegate' by
     */
    function increaseTotalStake(
        address _delegate,
        uint256 _amount,
        address _newPosPrev,
        address _newPosNext
    ) internal {
        if (isRegisteredTranscoder(_delegate)) {
            uint256 currStake = transcoderTotalStake(_delegate);
            uint256 newStake = currStake.add(_amount);
            uint256 currRound = roundsManager().currentRound();
            uint256 nextRound = currRound.add(1);

            // If the transcoder is already in the active set update its stake and return
            if (transcoderPool.contains(_delegate)) {
                transcoderPool.updateKey(_delegate, newStake, _newPosPrev, _newPosNext);
                nextRoundTotalActiveStake = nextRoundTotalActiveStake.add(_amount);
                Transcoder storage t = transcoders[_delegate];

                // currStake (the transcoder's delegatedAmount field) will reflect the transcoder's stake from lastActiveStakeUpdateRound
                // because it is updated every time lastActiveStakeUpdateRound is updated
                // The current active total stake is set to currStake to ensure that the value can be used in updateTranscoderWithRewards()
                // and updateTranscoderWithFees() when lastActiveStakeUpdateRound > currentRound
                if (t.lastActiveStakeUpdateRound < currRound) {
                    t.earningsPoolPerRound[currRound].setStake(currStake);
                }

                t.earningsPoolPerRound[nextRound].setStake(newStake);
                t.lastActiveStakeUpdateRound = nextRound;
            } else {
                // Check if the transcoder is eligible to join the active set in the update round
                tryToJoinActiveSet(_delegate, newStake, nextRound, _newPosPrev, _newPosNext);
            }
        }

        // Increase delegate's delegated amount
        delegators[_delegate].delegatedAmount = delegators[_delegate].delegatedAmount.add(_amount);
    }

    /**
     * @dev Decrease the total stake for a delegate and updates its 'lastActiveStakeUpdateRound'
     * @param _delegate The transcoder to decrease the stake for
     * @param _amount The amount to decrease the stake for '_delegate' by
     */
    function decreaseTotalStake(
        address _delegate,
        uint256 _amount,
        address _newPosPrev,
        address _newPosNext
    ) internal {
        if (transcoderPool.contains(_delegate)) {
            uint256 currStake = transcoderTotalStake(_delegate);
            uint256 newStake = currStake.sub(_amount);
            uint256 currRound = roundsManager().currentRound();
            uint256 nextRound = currRound.add(1);

            transcoderPool.updateKey(_delegate, newStake, _newPosPrev, _newPosNext);
            nextRoundTotalActiveStake = nextRoundTotalActiveStake.sub(_amount);
            Transcoder storage t = transcoders[_delegate];

            // currStake (the transcoder's delegatedAmount field) will reflect the transcoder's stake from lastActiveStakeUpdateRound
            // because it is updated every time lastActiveStakeUpdateRound is updated
            // The current active total stake is set to currStake to ensure that the value can be used in updateTranscoderWithRewards()
            // and updateTranscoderWithFees() when lastActiveStakeUpdateRound > currentRound
            if (t.lastActiveStakeUpdateRound < currRound) {
                t.earningsPoolPerRound[currRound].setStake(currStake);
            }

            t.lastActiveStakeUpdateRound = nextRound;
            t.earningsPoolPerRound[nextRound].setStake(newStake);
        }

        // Decrease old delegate's delegated amount
        delegators[_delegate].delegatedAmount = delegators[_delegate].delegatedAmount.sub(_amount);
    }

    /**
     * @dev Tries to add a transcoder to active transcoder pool, evicts the active transcoder with the lowest stake if the pool is full
     * @param _transcoder The transcoder to insert into the transcoder pool
     * @param _totalStake The total stake for '_transcoder'
     * @param _activationRound The round in which the transcoder should become active
     */
    function tryToJoinActiveSet(
        address _transcoder,
        uint256 _totalStake,
        uint256 _activationRound,
        address _newPosPrev,
        address _newPosNext
    ) internal {
        uint256 pendingNextRoundTotalActiveStake = nextRoundTotalActiveStake;

        if (transcoderPool.isFull()) {
            address lastTranscoder = transcoderPool.getLast();
            uint256 lastStake = transcoderTotalStake(lastTranscoder);

            // If the pool is full and the transcoder has less stake than the least stake transcoder in the pool
            // then the transcoder is unable to join the active set for the next round
            if (_totalStake <= lastStake) {
                return;
            }

            // Evict the least stake transcoder from the active set for the next round
            // Not zeroing 'Transcoder.lastActiveStakeUpdateRound' saves gas (5k when transcoder is evicted and 20k when transcoder is reinserted)
            // There should be no side-effects as long as the value is properly updated on stake updates
            // Not zeroing the stake on the current round's 'EarningsPool' saves gas and should have no side effects as long as
            // 'EarningsPool.setStake()' is called whenever a transcoder becomes active again.
            transcoderPool.remove(lastTranscoder);
            transcoders[lastTranscoder].deactivationRound = _activationRound;
            pendingNextRoundTotalActiveStake = pendingNextRoundTotalActiveStake.sub(lastStake);

            emit TranscoderDeactivated(lastTranscoder, _activationRound);
        }

        transcoderPool.insert(_transcoder, _totalStake, _newPosPrev, _newPosNext);
        pendingNextRoundTotalActiveStake = pendingNextRoundTotalActiveStake.add(_totalStake);
        Transcoder storage t = transcoders[_transcoder];
        t.lastActiveStakeUpdateRound = _activationRound;
        t.activationRound = _activationRound;
        t.deactivationRound = MAX_FUTURE_ROUND;
        t.earningsPoolPerRound[_activationRound].setStake(_totalStake);
        nextRoundTotalActiveStake = pendingNextRoundTotalActiveStake;
        emit TranscoderActivated(_transcoder, _activationRound);
    }

    /**
     * @dev Remove a transcoder from the pool and deactivate it
     */
    function resignTranscoder(address _transcoder) internal {
        // Not zeroing 'Transcoder.lastActiveStakeUpdateRound' saves gas (5k when transcoder is evicted and 20k when transcoder is reinserted)
        // There should be no side-effects as long as the value is properly updated on stake updates
        // Not zeroing the stake on the current round's 'EarningsPool' saves gas and should have no side effects as long as
        // 'EarningsPool.setStake()' is called whenever a transcoder becomes active again.
        transcoderPool.remove(_transcoder);
        nextRoundTotalActiveStake = nextRoundTotalActiveStake.sub(transcoderTotalStake(_transcoder));
        uint256 deactivationRound = roundsManager().currentRound().add(1);
        transcoders[_transcoder].deactivationRound = deactivationRound;
        emit TranscoderDeactivated(_transcoder, deactivationRound);
    }

    /**
     * @dev Update a transcoder with rewards and update the transcoder pool with an optional list hint if needed.
     * See SortedDoublyLL.sol for details on list hints
     * @param _transcoder Address of transcoder
     * @param _rewards Amount of rewards
     * @param _round Round that transcoder is updated
     * @param _newPosPrev Address of previous transcoder in pool if the transcoder is in the pool
     * @param _newPosNext Address of next transcoder in pool if the transcoder is in the pool
     */
    function updateTranscoderWithRewards(
        address _transcoder,
        uint256 _rewards,
        uint256 _round,
        address _newPosPrev,
        address _newPosNext
    ) internal {
        Transcoder storage t = transcoders[_transcoder];
        EarningsPool.Data storage earningsPool = t.earningsPoolPerRound[_round];
        EarningsPool.Data memory prevEarningsPool = cumulativeFactorsPool(t, t.lastRewardRound);

        t.activeCumulativeRewards = t.cumulativeRewards;

        uint256 transcoderCommissionRewards = MathUtils.percOf(_rewards, earningsPool.transcoderRewardCut);
        uint256 delegatorsRewards = _rewards.sub(transcoderCommissionRewards);
        // Calculate the rewards earned by the transcoder's earned rewards
        uint256 transcoderRewardStakeRewards = PreciseMathUtils.percOf(
            delegatorsRewards,
            t.activeCumulativeRewards,
            earningsPool.totalStake
        );
        // Track rewards earned by the transcoder based on its earned rewards and rewardCut
        t.cumulativeRewards = t.cumulativeRewards.add(transcoderRewardStakeRewards).add(transcoderCommissionRewards);
        // Update cumulative reward factor with new rewards
        // The cumulativeRewardFactor is used to calculate rewards for all delegators including the transcoder (self-delegated)
        // Note that delegatorsRewards includes transcoderRewardStakeRewards, but no delegator will claim that amount using
        // the earnings claiming algorithm and instead that amount is accounted for in the transcoder's cumulativeRewards field
        earningsPool.updateCumulativeRewardFactor(prevEarningsPool, delegatorsRewards);
        // Update transcoder's total stake with rewards
        increaseTotalStake(_transcoder, _rewards, _newPosPrev, _newPosNext);
    }

    /**
     * @dev Update a delegator with token pools shares from its lastClaimRound through a given round
     * @param _delegator Delegator address
     * @param _endRound The last round for which to update a delegator's stake with earnings pool shares
     * @param _lastClaimRound The round for which a delegator has last claimed earnings
     */
    function updateDelegatorWithEarnings(
        address _delegator,
        uint256 _endRound,
        uint256 _lastClaimRound
    ) internal {
        Delegator storage del = delegators[_delegator];
        uint256 startRound = _lastClaimRound.add(1);
        uint256 currentBondedAmount = del.bondedAmount;
        uint256 currentFees = del.fees;

        // Only will have earnings to claim if you have a delegate
        // If not delegated, skip the earnings claim process
        if (del.delegateAddress != address(0)) {
            (currentBondedAmount, currentFees) = pendingStakeAndFees(_delegator, _endRound);

            // Check whether the endEarningsPool is initialised
            // If it is not initialised set it's cumulative factors so that they can be used when a delegator
            // next claims earnings as the start cumulative factors (see delegatorCumulativeStakeAndFees())
            Transcoder storage t = transcoders[del.delegateAddress];
            EarningsPool.Data storage endEarningsPool = t.earningsPoolPerRound[_endRound];
            if (endEarningsPool.cumulativeRewardFactor == 0) {
                uint256 lastRewardRound = t.lastRewardRound;
                if (lastRewardRound < _endRound) {
                    endEarningsPool.cumulativeRewardFactor = cumulativeFactorsPool(t, lastRewardRound)
                        .cumulativeRewardFactor;
                }
            }
            if (endEarningsPool.cumulativeFeeFactor == 0) {
                uint256 lastFeeRound = t.lastFeeRound;
                if (lastFeeRound < _endRound) {
                    endEarningsPool.cumulativeFeeFactor = cumulativeFactorsPool(t, lastFeeRound).cumulativeFeeFactor;
                }
            }

            if (del.delegateAddress == _delegator) {
                t.cumulativeFees = 0;
                t.cumulativeRewards = 0;
                // activeCumulativeRewards is not cleared here because the next reward() call will set it to cumulativeRewards
            }
        }

        emit EarningsClaimed(
            del.delegateAddress,
            _delegator,
            currentBondedAmount.sub(del.bondedAmount),
            currentFees.sub(del.fees),
            startRound,
            _endRound
        );

        del.lastClaimRound = _endRound;
        // Rewards are bonded by default
        del.bondedAmount = currentBondedAmount;
        del.fees = currentFees;
    }

    /**
     * @dev Update the state of a delegator and its delegate by processing a rebond using an unbonding lock and update the transcoder pool with an optional
     * list hint if needed. See SortedDoublyLL.sol for details on list hints
     * @param _delegator Address of delegator
     * @param _unbondingLockId ID of unbonding lock to rebond with
     * @param _newPosPrev Address of previous transcoder in pool if the delegate is already in or joins the pool
     * @param _newPosNext Address of next transcoder in pool if the delegate is already in or joins the pool
     */
    function processRebond(
        address _delegator,
        uint256 _unbondingLockId,
        address _newPosPrev,
        address _newPosNext
    ) internal {
        Delegator storage del = delegators[_delegator];
        UnbondingLock storage lock = del.unbondingLocks[_unbondingLockId];

        require(isValidUnbondingLock(_delegator, _unbondingLockId), "invalid unbonding lock ID");

        uint256 amount = lock.amount;
        // Increase delegator's bonded amount
        del.bondedAmount = del.bondedAmount.add(amount);

        // Delete lock
        delete del.unbondingLocks[_unbondingLockId];

        increaseTotalStake(del.delegateAddress, amount, _newPosPrev, _newPosNext);

        emit Rebond(del.delegateAddress, _delegator, _unbondingLockId, amount);
    }

    /**
     * @dev Return LivepeerToken interface
     * @return Livepeer token contract registered with Controller
     */
    function livepeerToken() internal view returns (ILivepeerToken) {
        return ILivepeerToken(controller.getContract(keccak256("LivepeerToken")));
    }

    /**
     * @dev Return Minter interface
     * @return Minter contract registered with Controller
     */
    function minter() internal view returns (IMinter) {
        return IMinter(controller.getContract(keccak256("Minter")));
    }

    /**
     * @dev Return Address of L2Migrator
     * @return l2Migrator contract address registered with Controller
     */
    function l2Migrator() internal view returns (address) {
        return controller.getContract(keccak256("L2Migrator"));
    }

    /**
     * @dev Return RoundsManager interface
     * @return RoundsManager contract registered with Controller
     */
    function roundsManager() internal view returns (IRoundsManager) {
        return IRoundsManager(controller.getContract(keccak256("RoundsManager")));
    }

    function _onlyTicketBroker() internal view {
        require(msg.sender == controller.getContract(keccak256("TicketBroker")), "caller must be TicketBroker");
    }

    function _onlyRoundsManager() internal view {
        require(msg.sender == controller.getContract(keccak256("RoundsManager")), "caller must be RoundsManager");
    }

    function _onlyVerifier() internal view {
        require(msg.sender == controller.getContract(keccak256("Verifier")), "caller must be Verifier");
    }

    function _currentRoundInitialized() internal view {
        require(roundsManager().currentRoundInitialized(), "current round is not initialized");
    }

    function _autoClaimEarnings(address _delegator) internal {
        uint256 currentRound = roundsManager().currentRound();
        uint256 lastClaimRound = delegators[_delegator].lastClaimRound;
        if (lastClaimRound < currentRound) {
            updateDelegatorWithEarnings(_delegator, currentRound, lastClaimRound);
        }
    }
}

Contract ABI

[{"inputs":[{"internalType":"address","name":"_controller","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"oldDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":false,"internalType":"uint256","name":"additionalAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"bondedAmount","type":"uint256"}],"name":"Bond","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":false,"internalType":"uint256","name":"rewards","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"startRound","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endRound","type":"uint256"}],"name":"EarningsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"param","type":"string"}],"name":"ParameterUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":false,"internalType":"uint256","name":"unbondingLockId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Rebond","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"transcoder","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Reward","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"controller","type":"address"}],"name":"SetController","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"transcoder","type":"address"},{"indexed":false,"internalType":"uint256","name":"activationRound","type":"uint256"}],"name":"TranscoderActivated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"transcoder","type":"address"},{"indexed":false,"internalType":"uint256","name":"deactivationRound","type":"uint256"}],"name":"TranscoderDeactivated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"transcoder","type":"address"},{"indexed":false,"internalType":"address","name":"finder","type":"address"},{"indexed":false,"internalType":"uint256","name":"penalty","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"finderReward","type":"uint256"}],"name":"TranscoderSlashed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"transcoder","type":"address"},{"indexed":false,"internalType":"uint256","name":"rewardCut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"feeShare","type":"uint256"}],"name":"TranscoderUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldDelegator","type":"address"},{"indexed":true,"internalType":"address","name":"newDelegator","type":"address"},{"indexed":false,"internalType":"uint256","name":"oldUnbondingLockId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newUnbondingLockId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TransferBond","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":false,"internalType":"uint256","name":"unbondingLockId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"withdrawRound","type":"uint256"}],"name":"Unbond","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":false,"internalType":"uint256","name":"unbondingLockId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"withdrawRound","type":"uint256"}],"name":"WithdrawStake","type":"event"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_to","type":"address"}],"name":"bond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"address","name":"_oldDelegateNewPosPrev","type":"address"},{"internalType":"address","name":"_oldDelegateNewPosNext","type":"address"},{"internalType":"address","name":"_currDelegateNewPosPrev","type":"address"},{"internalType":"address","name":"_currDelegateNewPosNext","type":"address"}],"name":"bondForWithHint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"address","name":"_oldDelegateNewPosPrev","type":"address"},{"internalType":"address","name":"_oldDelegateNewPosNext","type":"address"},{"internalType":"address","name":"_currDelegateNewPosPrev","type":"address"},{"internalType":"address","name":"_currDelegateNewPosNext","type":"address"}],"name":"bondWithHint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_endRound","type":"uint256"}],"name":"claimEarnings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"contract IController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentRoundTotalActiveStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_delegator","type":"address"}],"name":"delegatorStatus","outputs":[{"internalType":"enum BondingManager.DelegatorStatus","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_delegator","type":"address"}],"name":"getDelegator","outputs":[{"internalType":"uint256","name":"bondedAmount","type":"uint256"},{"internalType":"uint256","name":"fees","type":"uint256"},{"internalType":"address","name":"delegateAddress","type":"address"},{"internalType":"uint256","name":"delegatedAmount","type":"uint256"},{"internalType":"uint256","name":"startRound","type":"uint256"},{"internalType":"uint256","name":"lastClaimRound","type":"uint256"},{"internalType":"uint256","name":"nextUnbondingLockId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_delegator","type":"address"},{"internalType":"uint256","name":"_unbondingLockId","type":"uint256"}],"name":"getDelegatorUnbondingLock","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"withdrawRound","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFirstTranscoderInPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_transcoder","type":"address"}],"name":"getNextTranscoderInPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalBonded","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_transcoder","type":"address"}],"name":"getTranscoder","outputs":[{"internalType":"uint256","name":"lastRewardRound","type":"uint256"},{"internalType":"uint256","name":"rewardCut","type":"uint256"},{"internalType":"uint256","name":"feeShare","type":"uint256"},{"internalType":"uint256","name":"lastActiveStakeUpdateRound","type":"uint256"},{"internalType":"uint256","name":"activationRound","type":"uint256"},{"internalType":"uint256","name":"deactivationRound","type":"uint256"},{"internalType":"uint256","name":"activeCumulativeRewards","type":"uint256"},{"internalType":"uint256","name":"cumulativeRewards","type":"uint256"},{"internalType":"uint256","name":"cumulativeFees","type":"uint256"},{"internalType":"uint256","name":"lastFeeRound","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_transcoder","type":"address"},{"internalType":"uint256","name":"_round","type":"uint256"}],"name":"getTranscoderEarningsPoolForRound","outputs":[{"internalType":"uint256","name":"totalStake","type":"uint256"},{"internalType":"uint256","name":"transcoderRewardCut","type":"uint256"},{"internalType":"uint256","name":"transcoderFeeShare","type":"uint256"},{"internalType":"uint256","name":"cumulativeRewardFactor","type":"uint256"},{"internalType":"uint256","name":"cumulativeFeeFactor","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTranscoderPoolMaxSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTranscoderPoolSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_transcoder","type":"address"}],"name":"isActiveTranscoder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_transcoder","type":"address"}],"name":"isRegisteredTranscoder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_delegator","type":"address"},{"internalType":"uint256","name":"_unbondingLockId","type":"uint256"}],"name":"isValidUnbondingLock","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextRoundTotalActiveStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_delegator","type":"address"},{"internalType":"uint256","name":"_endRound","type":"uint256"}],"name":"pendingFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_delegator","type":"address"},{"internalType":"uint256","name":"_endRound","type":"uint256"}],"name":"pendingStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_unbondingLockId","type":"uint256"}],"name":"rebond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_unbondingLockId","type":"uint256"}],"name":"rebondFromUnbonded","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_unbondingLockId","type":"uint256"},{"internalType":"address","name":"_newPosPrev","type":"address"},{"internalType":"address","name":"_newPosNext","type":"address"}],"name":"rebondFromUnbondedWithHint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_unbondingLockId","type":"uint256"},{"internalType":"address","name":"_newPosPrev","type":"address"},{"internalType":"address","name":"_newPosNext","type":"address"}],"name":"rebondWithHint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newPosPrev","type":"address"},{"internalType":"address","name":"_newPosNext","type":"address"}],"name":"rewardWithHint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_controller","type":"address"}],"name":"setController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setCurrentRoundTotalActiveStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numActiveTranscoders","type":"uint256"}],"name":"setNumActiveTranscoders","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"_unbondingPeriod","type":"uint64"}],"name":"setUnbondingPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_transcoder","type":"address"},{"internalType":"address","name":"_finder","type":"address"},{"internalType":"uint256","name":"_slashAmount","type":"uint256"},{"internalType":"uint256","name":"_finderFee","type":"uint256"}],"name":"slashTranscoder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"targetContractId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardCut","type":"uint256"},{"internalType":"uint256","name":"_feeShare","type":"uint256"}],"name":"transcoder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_transcoder","type":"address"}],"name":"transcoderStatus","outputs":[{"internalType":"enum BondingManager.TranscoderStatus","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_transcoder","type":"address"}],"name":"transcoderTotalStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardCut","type":"uint256"},{"internalType":"uint256","name":"_feeShare","type":"uint256"},{"internalType":"address","name":"_newPosPrev","type":"address"},{"internalType":"address","name":"_newPosNext","type":"address"}],"name":"transcoderWithHint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_delegator","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_oldDelegateNewPosPrev","type":"address"},{"internalType":"address","name":"_oldDelegateNewPosNext","type":"address"},{"internalType":"address","name":"_newDelegateNewPosPrev","type":"address"},{"internalType":"address","name":"_newDelegateNewPosNext","type":"address"}],"name":"transferBond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"unbond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_newPosPrev","type":"address"},{"internalType":"address","name":"_newPosNext","type":"address"}],"name":"unbondWithHint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unbondingPeriod","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_transcoder","type":"address"},{"internalType":"uint256","name":"_fees","type":"uint256"},{"internalType":"uint256","name":"_round","type":"uint256"}],"name":"updateTranscoderWithFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_unbondingLockId","type":"uint256"}],"name":"withdrawStake","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000d8e8328501e9645d16cf49539efc04f734606ee4

-----Decoded View---------------
Arg [0] : _controller (address): 0xd8e8328501e9645d16cf49539efc04f734606ee4

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


Library Used



Deployed ByteCode Sourcemap

44021:73236:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80289:731;;;;;;:::i;:::-;;:::i;:::-;;72807:2504;;;;;;:::i;:::-;;:::i;93699:295::-;;;;;;:::i;:::-;;:::i;:::-;;;2057:14:1;;2050:22;2032:41;;2020:2;2005:18;93699:295:0;;;;;;;;94665:309;;;;;;:::i;:::-;;:::i;85976:741::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;53730:84::-;;;:::i;58949:1888::-;;;;;;:::i;:::-;;:::i;93125:145::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;3486:32:1;;;3468:51;;3456:2;3441:18;93125:145:0;3322:203:1;89342:773:0;;;;;;:::i;:::-;-1:-1:-1;;;;;89741:24:0;;;89484:18;89741:24;;;:11;:24;;;;;;;;:53;;;:45;;;;:53;;;;;;89820:23;;89876:32;;;;89940:31;;;;90007:35;;;;90075:32;;;;;89820:23;;89876:32;;89940:31;89342:773;;;;;3789:25:1;;;3845:2;3830:18;;3823:34;;;;3873:18;;;3866:34;;;;3931:2;3916:18;;3909:34;3974:3;3959:19;;3952:35;3776:3;3761:19;89342:773:0;3530:463:1;61060:216:0;;;;;;:::i;:::-;;:::i;52015:910::-;;;;;;:::i;:::-;;:::i;50941:108::-;;;;;;:::i;:::-;;:::i;92491:113::-;;;:::i;:::-;;;4329:25:1;;;4317:2;4302:18;92491:113:0;4183:177:1;62585:1348:0;;;;;;:::i;:::-;;:::i;51651:168::-;;;;;;:::i;:::-;;:::i;54020:4504::-;;;;;;:::i;:::-;;:::i;91805:329::-;;;;;;:::i;:::-;-1:-1:-1;;;;;92018:22:0;;;;91934:14;92018:22;;;:10;:22;;;;;;;;:55;;;:37;;;;:55;;;92094:11;;92107:18;;;;;92094:11;;91805:329;;;;;5457:25:1;;;5513:2;5498:18;;5491:34;;;;5430:18;91805:329:0;5283:248:1;47326:43:0;;;;;;50299:152;;;;;;:::i;:::-;;:::i;47467:40::-;;;;;;5352:31;;;;;;92253:119;;;:::i;93396:110::-;93470:28;;93396:110;;87677:1034;;;;;;:::i;:::-;-1:-1:-1;;;;;88205:24:0;87783:23;88205:24;;;:11;:24;;;;;;;;88260:17;;88300:11;;;;88333:10;;;;88383:28;;;;88440:17;;;;88488:19;;;;88544:25;;;;88600:19;;;;88647:16;;;;88689:14;;;;;88260:17;;88300:11;;88333:10;88383:28;;88440:17;;88488:19;;88544:25;;88600:19;;87677:1034;;;;;6370:25:1;;;6426:2;6411:18;;6404:34;;;;6454:18;;;6447:34;;;;6512:2;6497:18;;6490:34;;;;6555:3;6540:19;;6533:35;;;;6599:3;6584:19;;6577:35;6643:3;6628:19;;6621:35;6687:3;6672:19;;6665:35;6731:3;6716:19;;6709:35;6775:3;6760:19;;6753:35;6357:3;6342:19;87677:1034:0;5971:823:1;49700:217:0;;;;;;:::i;:::-;;:::i;94174:216::-;;;;;;:::i;:::-;;:::i;70711:510::-;;;;;;:::i;:::-;;:::i;44529:29::-;;;;;;;;;;;;7860:18:1;7848:31;;;7830:50;;7818:2;7803:18;44529:29:0;7686:200:1;61433:145:0;;;:::i;78913:445::-;;;;;;:::i;:::-;;:::i;81787:1981::-;;;;;;:::i;:::-;;:::i;92766:117::-;;;:::i;85572:228::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3980:168::-;;;;;;:::i;:::-;;:::i;76126:1870::-;;;;;;:::i;:::-;;:::i;84099:326::-;;;;;;:::i;:::-;;:::i;85245:146::-;;;;;;:::i;:::-;;:::i;90750:727::-;;;;;;:::i;:::-;-1:-1:-1;;;;;91141:22:0;;;90854:20;91141:22;;;:10;:22;;;;;;;;91191:16;;91225:8;;;;91262:19;;;;91310;;;;91353:14;;;;91395:18;;;;91446:23;;;;;91191:16;;91225:8;;91262:19;;;;;91310;;91353:14;;91395:18;;90750:727;;;;;9317:25:1;;;9373:2;9358:18;;9351:34;;;;-1:-1:-1;;;;;9421:32:1;;;9401:18;;;9394:60;;;;9485:2;9470:18;;9463:34;;;;9528:3;9513:19;;9506:35;9441:3;9557:19;;9550:35;;;;9616:3;9601:19;;9594:35;9304:3;9289:19;90750:727:0;9002:633:1;52996:629:0;;;;;;:::i;:::-;;:::i;50654:146::-;;;;;;:::i;:::-;;:::i;51282:126::-;;;;;;:::i;:::-;;:::i;65492:3758::-;;;;;;:::i;:::-;;:::i;49329:187::-;;;;;;:::i;:::-;;:::i;84736:323::-;;;;;;:::i;:::-;;:::i;3190:29::-;;;;;-1:-1:-1;;;;;3190:29:0;;;80289:731;3568:22;:20;:22::i;:::-;48305:26:::1;:24;:26::i;:::-;80518:10:::2;48500:30;48519:10;48500:18;:30::i;:::-;80580:24:::3;80549:27;80565:10;80549:15;:27::i;:::-;:55;;;;;;;;:::i;:::-;;80541:91;;;::::0;-1:-1:-1;;;80541:91:0;;12035:2:1;80541:91:0::3;::::0;::::3;12017:21:1::0;12074:2;12054:18;;;12047:30;12113:25;12093:18;;;12086:53;12156:18;;80541:91:0::3;;;;;;;;;80755:37;80790:1;80755:15;:13;:15::i;:::-;-1:-1:-1::0;;;;;80755:28:0::3;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:34:::0;::::3;:37::i;:::-;80730:10;80719:22;::::0;;;:10:::3;:22;::::0;;;;:33:::3;::::0;::::3;:73:::0;;;;80840:38:::3;::::0;;::::3;:44:::0;;-1:-1:-1;;;;;;80840:44:0::3;-1:-1:-1::0;;;;;80840:44:0;::::3;;::::0;;80943:69:::3;::::0;80969:16;80987:11;81000;80943:13:::3;:69::i;:::-;48342:1:::2;80289:731:::0;;;;:::o;72807:2504::-;3568:22;:20;:22::i;:::-;48305:26:::1;:24;:26::i;:::-;73247:30:::2;73266:10;73247:18;:30::i;:::-;73326:10;73288:24;73315:22:::0;;;:10:::2;:22;::::0;;;;73549::::2;::::0;::::2;::::0;-1:-1:-1;;;;;73549:22:0::2;73584:71;73599:7:::0;73608:22;73632;73584:14:::2;:71::i;:::-;-1:-1:-1::0;;;;;73695:22:0;::::2;73668:24;73695:22:::0;;;:10:::2;:22;::::0;;;;73762:26:::2;::::0;::::2;::::0;73695:22;;73668:24;73762:33:::2;::::0;73793:1:::2;73762:30;:33::i;:::-;73730:65;;73806:21;73830:6;:21;;:44;73852:21;73830:44;;;;;;;;;;;:58;;;73806:82;;73948:6;:21;;:44;73970:21;73948:44;;;;;;;;;;;;73941:51:::0;::::2;;;;;;;;;;;;;74043:29;74075:6;:26;;;74043:58;;74161:64;;;;;;;;74185:7;74161:64;;;;74209:13;74161:64;;::::0;74114:6:::2;:21;;:44;74136:21;74114:44;;;;;;;;;;;:111;;;;;;;;;;;;;;;;;;;74265:33;74296:1;74265:6;:26;;;:30;;:33;;;;:::i;:::-;74236:26;::::0;::::2;:62:::0;74316:91:::2;::::0;;12576:25:1;;;12632:2;12617:18;;12610:34;;;12660:18;;;12653:34;;;-1:-1:-1;;;;;74316:91:0;::::2;::::0;74329:10:::2;::::0;74316:91:::2;::::0;12564:2:1;12549:18;74316:91:0::2;;;;;;;74493:20;74516:15;:13;:15::i;:::-;-1:-1:-1::0;;;;;74516:28:0::2;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;74582:21;::::0;::::2;::::0;74493:53;;-1:-1:-1;74618:29:0;;::::2;74614:131;;;74664:69;74692:10;74704:12;74718:14;74664:27;:69::i;:::-;74799:22;::::0;::::2;::::0;-1:-1:-1;;;;;74799:22:0::2;:36:::0;:64;::::2;;;-1:-1:-1::0;74839:19:0;;:24;74799:64:::2;74795:136;;;74880:22;::::0;::::2;:39:::0;;-1:-1:-1;;;;;;74880:39:0::2;-1:-1:-1::0;;;;;74880:39:0;::::2;;::::0;;74795:136:::2;75055:24;75024:27;75040:10;75024:15;:27::i;:::-;:55;;;;;;;;:::i;:::-;;75020:127;;;75116:19;:12:::0;75133:1:::2;75116:16;:19::i;:::-;75096:17;::::0;::::2;:39:::0;75020:127:::2;75207:96;75221:10;75233:21;75256:22;75280;75207:13;:96::i;:::-;73106:2205;;;;;;;;72807:2504:::0;;;;;;:::o;93699:295::-;-1:-1:-1;;;;;93809:24:0;;93769:4;93809:24;;;:11;:24;;;;;93769:4;93867:15;:13;:15::i;:::-;-1:-1:-1;;;;;93867:28:0;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;93844:53;;93936:12;93915:1;:17;;;:33;;:71;;;;;93967:1;:19;;;93952:12;:34;93915:71;93908:78;93699:295;-1:-1:-1;;;;93699:295:0:o;94665:309::-;-1:-1:-1;;;;;94893:22:0;;;;94762:4;94893:22;;;:10;:22;;;;;;;;:55;;;:37;;;;:55;;;:69;;;:73;;;94665:309::o;85976:741::-;-1:-1:-1;;;;;86094:22:0;;86042:15;86094:22;;;:10;:22;;;;;86133:16;;86129:581;;-1:-1:-1;86228:24:0;;85976:741;-1:-1:-1;;85976:741:0:o;86129:581::-;86291:15;:13;:15::i;:::-;-1:-1:-1;;;;;86291:28:0;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;86274:3;:14;;;:47;86270:440;;;-1:-1:-1;86400:23:0;;85976:741;-1:-1:-1;;85976:741:0:o;86270:440::-;-1:-1:-1;86676:22:0;;85976:741;-1:-1:-1;;85976:741:0:o;53730:84::-;53768:38;53791:1;53803;53768:14;:38::i;:::-;53730:84::o;58949:1888::-;3568:22;:20;:22::i;:::-;48170:15:::1;:13;:15::i;:::-;-1:-1:-1::0;;;;;59174:23:0;::::2;59150:21;59174:23:::0;;;:10:::2;:23;::::0;;;;59214:16;;:20;59210:1620:::2;;-1:-1:-1::0;;;;;59286:23:0;::::2;59251:15;59286:23:::0;;;:10:::2;:23;::::0;;;;:36;59269:68:::2;::::0;59324:12;59269:16:::2;:68::i;:::-;59406:36;::::0;-1:-1:-1;;;59406:36:0;;:14:::2;:36;::::0;::::2;12902:25:1::0;-1:-1:-1;;;;;12963:32:1;;12943:18;;;12936:60;59251:86:0;;-1:-1:-1;59406:23:0::2;::::0;::::2;::::0;12875:18:1;;59406:36:0::2;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59402:106;;;59463:29;59480:11;59463:16;:29::i;:::-;59581:16:::0;;:29:::2;::::0;59602:7;59581:20:::2;:29::i;:::-;59562:48:::0;;59732:22:::2;59700:28;59716:11;59700:15;:28::i;:::-;:54;;;;;;;;:::i;:::-;;59696:245;;;59836:19;::::0;::::2;::::0;-1:-1:-1;;;;;59836:19:0::2;59825:31;::::0;;;:10:::2;:31;::::0;;;;;;;:47:::2;::::0;:100:::2;::::0;59899:7;59825:51:::2;:100::i;:::-;59786:19;::::0;::::2;::::0;-1:-1:-1;;;;;59786:19:0::2;59775:31;::::0;;;:10:::2;:31;::::0;;;;;;;:47:::2;:150:::0;59696:245:::2;60014:7:::0;-1:-1:-1;;;;;60104:21:0;::::2;::::0;60100:636:::2;;60146:20;60169:37;60186:7;60195:10;60169:16;:37::i;:::-;60146:60;;60225:8;:6;:8::i;:::-;:53;::::0;-1:-1:-1;;;60225:53:0;;-1:-1:-1;;;;;13481:32:1;;;60225:53:0::2;::::0;::::2;13463:51:1::0;13530:18;;;13523:34;;;60225:30:0;;;::::2;::::0;::::2;::::0;13436:18:1;;60225:53:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;60366:8;:6;:8::i;:::-;-1:-1:-1::0;;;;;60366:26:0::2;;60393:28;:10:::0;60408:12;60393:14:::2;:28::i;:::-;60366:56;;;;;;;;;;;;;4329:25:1::0;;4317:2;4302:18;;4183:177;60366:56:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;60448:62:0::2;::::0;;-1:-1:-1;;;;;13788:32:1;;;13770:51;;13852:2;13837:18;;13830:34;;;13880:18;;;13873:34;;;60448:62:0;;::::2;::::0;-1:-1:-1;60448:62:0::2;::::0;-1:-1:-1;13758:2:1;13743:18;60448:62:0::2;;;;;;;60127:399;60100:636;;;60602:8;:6;:8::i;:::-;-1:-1:-1::0;;;;;60602:26:0::2;;60629:10;60602:38;;;;;;;;;;;;;4329:25:1::0;;4317:2;4302:18;;4183:177;60602:38:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;60666:54:0::2;::::0;;60705:1:::2;13770:51:1::0;;;13852:2;13837:18;;13830:34;;;13880:18;;;13873:34;60666:54:0;;-1:-1:-1;;;;;60666:54:0;::::2;::::0;-1:-1:-1;60666:54:0::2;::::0;-1:-1:-1;60666:54:0;;;;13758:2:1;60666:54:0;;::::2;60100:636;59236:1511;;59210:1620;;;60773:45;::::0;;-1:-1:-1;;;;;13788:32:1;;;13770:51;;60813:1:0::2;13852:2:1::0;13837:18;;13830:34;;;13880:18;;;13873:34;;;;60773:45:0;;::::2;::::0;::::2;::::0;13758:2:1;13743:18;60773:45:0::2;;;;;;;;59139:1698;58949:1888:::0;;;;:::o;93125:145::-;93227:35;;-1:-1:-1;;;93227:35:0;;:14;:35;;;12902:25:1;-1:-1:-1;;;;;12963:32:1;;12943:18;;;12936:60;93200:7:0;;93227:22;;;;12875:18:1;;93227:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;93220:42;93125:145;-1:-1:-1;;93125:145:0:o;61060:216::-;3568:22;:20;:22::i;:::-;48305:26:::1;:24;:26::i;:::-;61238:30:::2;61257:10;61238:18;:30::i;:::-;61060:216:::0;:::o;52015:910::-;3568:22;:20;:22::i;:::-;48305:26:::1;:24;:26::i;:::-;52163:10:::2;52128:21;52152:22:::0;;;:10:::2;:22;::::0;;;;;;;52214:36;;;:18:::2;::::0;::::2;:36:::0;;;;;;52152:22;;52271:50:::2;::::0;52233:16;52271:20:::2;:50::i;:::-;52263:88;;;::::0;-1:-1:-1;;;52263:88:0;;15100:2:1;52263:88:0::2;::::0;::::2;15082:21:1::0;15139:2;15119:18;;;15112:30;-1:-1:-1;;;15158:18:1;;;15151:55;15223:18;;52263:88:0::2;14898:349:1::0;52263:88:0::2;52406:15;:13;:15::i;:::-;-1:-1:-1::0;;;;;52406:28:0::2;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52384:4;:18;;;:52;;52362:161;;;::::0;-1:-1:-1;;;52362:161:0;;15454:2:1;52362:161:0::2;::::0;::::2;15436:21:1::0;15493:2;15473:18;;;15466:30;15532:34;15512:18;;;15505:62;15603:29;15583:18;;;15576:57;15650:19;;52362:161:0::2;15252:423:1::0;52362:161:0::2;52553:11:::0;;52599:18:::2;::::0;;::::2;::::0;52536:14:::2;52669:36:::0;;;:18:::2;::::0;::::2;:36;::::0;;;;52662:43;;;;;::::2;::::0;;;;52783:8:::2;:6;:8::i;:::-;:50;::::0;-1:-1:-1;;;52783:50:0;;52814:10:::2;52783:50;::::0;::::2;13463:51:1::0;13530:18;;;13523:34;;;-1:-1:-1;;;;;52783:30:0;;;::::2;::::0;::::2;::::0;13436:18:1;;52783:50:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;52851:66:0::2;::::0;;12576:25:1;;;12632:2;12617:18;;12610:34;;;12660:18;;;12653:34;;;52865:10:0::2;::::0;-1:-1:-1;52851:66:0::2;::::0;-1:-1:-1;12564:2:1;12549:18;52851:66:0::2;12374:319:1::0;50941:108:0;50994:47;51009:7;51026:1;51038;50994:14;:47::i;92491:113::-;92572:24;;-1:-1:-1;;;92572:24:0;;:14;:24;;;4329:25:1;92545:7:0;;92572:22;;;;4302:18:1;;92572:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;92565:31;;92491:113;:::o;62585:1348::-;3568:22;:20;:22::i;:::-;48305:26:::1;:24;:26::i;:::-;62808:15:::2;:13;:15::i;:::-;-1:-1:-1::0;;;;;62808:34:0::2;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62807:37;62799:105;;;::::0;-1:-1:-1;;;62799:105:0;;16094:2:1;62799:105:0::2;::::0;::::2;16076:21:1::0;16133:2;16113:18;;;16106:30;16172:34;16152:18;;;16145:62;16243:25;16223:18;;;16216:53;16286:19;;62799:105:0::2;15892:419:1::0;62799:105:0::2;62923:31;62943:10;30501:7:::0;-1:-1:-1;30765:23:0;;30682:114;62923:31:::2;62915:72;;;::::0;-1:-1:-1;;;62915:72:0;;16518:2:1;62915:72:0::2;::::0;::::2;16500:21:1::0;16557:2;16537:18;;;16530:30;16596;16576:18;;;16569:58;16644:18;;62915:72:0::2;16316:352:1::0;62915:72:0::2;63006:30;63026:9;30501:7:::0;-1:-1:-1;30765:23:0;;30682:114;63006:30:::2;62998:70;;;::::0;-1:-1:-1;;;62998:70:0;;16875:2:1;62998:70:0::2;::::0;::::2;16857:21:1::0;16914:2;16894:18;;;16887:30;16953:29;16933:18;;;16926:57;17000:18;;62998:70:0::2;16673:351:1::0;62998:70:0::2;63087:34;63110:10;63087:22;:34::i;:::-;63079:76;;;::::0;-1:-1:-1;;;63079:76:0;;17231:2:1;63079:76:0::2;::::0;::::2;17213:21:1::0;17270:2;17250:18;;;17243:30;17309:31;17289:18;;;17282:59;17358:18;;63079:76:0::2;17029:353:1::0;63079:76:0::2;63203:10;63168:20;63191:23:::0;;;:11:::2;:23;::::0;;;;;63248:15:::2;:13;:15::i;:::-;-1:-1:-1::0;;;;;63248:28:0::2;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63225:53;;63314:30;63333:10;63314:18;:30::i;:::-;63313:31;:68;;;-1:-1:-1::0;63348:17:0;;:33;::::2;63313:68;63291:197;;;::::0;-1:-1:-1;;;63291:197:0;;17589:2:1;63291:197:0::2;::::0;::::2;17571:21:1::0;17628:2;17608:18;;;17601:30;17667:34;17647:18;;;17640:62;17738:34;17718:18;;;17711:62;-1:-1:-1;;;17789:19:1;;;17782:46;17845:19;;63291:197:0::2;17387:483:1::0;63291:197:0::2;63501:11;::::0;::::2;:24:::0;;;63536:10:::2;::::0;::::2;:22:::0;;;63576:35:::2;::::0;-1:-1:-1;;;63576:35:0;;:14:::2;:35;::::0;::::2;12902:25:1::0;63600:10:0::2;12943:18:1::0;;;12936:60;63576:23:0::2;::::0;::::2;::::0;12875:18:1;;63576:35:0::2;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63571:286;;63665:10;63694:22;::::0;;;:10:::2;:22;::::0;;;;;;;:38:::2;::::0;63628:217:::2;::::0;63665:10;63751:19:::2;:12:::0;63768:1:::2;63751:16;:19::i;:::-;63789:11;63819;63628:18;:217::i;:::-;63874:51;::::0;;5457:25:1;;;5513:2;5498:18;;5491:34;;;63891:10:0::2;::::0;63874:51:::2;::::0;5430:18:1;63874:51:0::2;;;;;;;62788:1145;;62585:1348:::0;;;;:::o;51651:168::-;51738:73;51765:3;51770:16;51796:1;51808;51738:26;:73::i;:::-;51651:168;;:::o;54020:4504::-;3568:22;:20;:22::i;:::-;47923:19:::1;:17;:19::i;:::-;54274:35:::2;54297:11;54274:22;:35::i;:::-;54266:77;;;::::0;-1:-1:-1;;;54266:77:0;;17231:2:1;54266:77:0::2;::::0;::::2;17213:21:1::0;17270:2;17250:18;;;17243:30;17309:31;17289:18;;;17282:59;17358:18;;54266:77:0::2;17029:353:1::0;54266:77:0::2;54356:20;54379:15;:13;:15::i;:::-;-1:-1:-1::0;;;;;54379:28:0::2;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;54445:24:0;::::2;54422:20;54445:24:::0;;;:11:::2;:24;::::0;;;;;;;54508:17;;54570:25:::2;::::0;::::2;::::0;54798:36;;;:22:::2;::::0;::::2;:36:::0;;;;;;54356:53;;-1:-1:-1;54445:24:0;54508:17;;54889:51:::2;54445:24:::0;54920:19:::2;54356:53:::0;54937:1:::2;54920:16;:19::i;:::-;54889:27;:51::i;:::-;54845:95;;55308:15;55293:12;:30;55289:898;;;55367:11;::::0;;::::2;::::0;55380:10:::2;::::0;;::::2;::::0;35379:32;;;:45;;;;35435:31;;:43;55434:28:::2;::::0;::::2;::::0;55481:30;;::::2;55477:144;;;55554:39;::::0;;;:22:::2;::::0;::::2;:39;::::0;;;;:50;35807:32;;55532:73:::2;56156:1;:19;;;56130:45;;55325:862;55289:898;56220:23:::0;;56258:39:::2;::::0;::::2;::::0;:44;:79;::::2;;;;56325:12;56306:15;:31;56258:79;56254:1108;;;56677:11;56691:8;:6;:8::i;:::-;56677:22;;56714:15;56732:191;56774:58;56806:3;-1:-1:-1::0;;;;;56806:23:0::2;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56774:3;-1:-1:-1::0;;;;;56774:25:0::2;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;:58;56851:10;56880:28;;56732:23;:191::i;:::-;56714:209;;56938:35;56976:59;56993:7;57002:12;:32;;;56976:16;:59::i;:::-;56938:97:::0;-1:-1:-1;57050:25:0::2;57078:40;:7:::0;56938:97;57078:11:::2;:40::i;:::-;57219:35;::::0;::::2;::::0;57050:68;;-1:-1:-1;57177:173:0::2;::::0;57273:10;57302:33:::2;57050:68:::0;57273:10;57302:21:::2;:33::i;:::-;57177:23;:173::i;:::-;57135:39;::::0;::::2;:215:::0;-1:-1:-1;;;;56254:1108:0::2;57374:22;57399:56;57416:5;57423:12;:31;;;57399:16;:56::i;:::-;57374:81:::0;-1:-1:-1;57466:32:0::2;57501:25;:5:::0;57374:81;57501:9:::2;:25::i;:::-;57466:60;;57610:33;57646:126;57684:14;57713:23;57751:10;57646:23;:126::i;:::-;57610:162;;57891:77;57943:24;57891:47;57912:25;57891:1;:16;;;:20;;:47;;;;:::i;:77::-;57872:16;::::0;::::2;:96:::0;58402:72:::2;:12:::0;58441:16;58459:14;58402:38:::2;:72::i;:::-;-1:-1:-1::0;;;;58487:14:0::2;::::0;;::::2;:29:::0;;;;-1:-1:-1;;;;;;;54020:4504:0:o;50299:152::-;50378:65;50397:10;50409:9;50428:1;50440;50378:18;:65::i;92253:119::-;92337:27;;-1:-1:-1;;;92337:27:0;;:14;:27;;;4329:25:1;92310:7:0;;92337:25;;;;4302:18:1;;92337:27:0;4183:177:1;49700:217:0;3434:22;:20;:22::i;:::-;49804:48:::1;::::0;-1:-1:-1;;;49804:48:0;;:14:::1;:48;::::0;::::1;5457:25:1::0;5498:18;;;5491:34;;;49804:25:0::1;::::0;::::1;::::0;5430:18:1;;49804:48:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49870:39;;;;;18360:2:1::0;18342:21;;;18399:2;18379:18;;;18372:30;-1:-1:-1;;;18433:2:1;18418:18;;18411:50;18493:2;18478:18;;18158:344;49870:39:0::1;;;;;;;;49700:217:::0;:::o;94174:216::-;-1:-1:-1;;;;;94287:23:0;;;94248:4;94287:23;;;:10;:23;;;;;94328:17;;;;94248:4;;94287:23;;94328:17;;:32;:54;;;;-1:-1:-1;94364:14:0;;:18;;94328:54;94321:61;94174:216;-1:-1:-1;;;94174:216:0:o;70711:510::-;70972:241;71002:7;71024:10;71049:3;71067:22;71104;71141:23;71179;70972:15;:241::i;:::-;70711:510;;;;;;:::o;61433:145::-;48051:20;:18;:20::i;:::-;61545:25:::1;::::0;61514:28:::1;:56:::0;61433:145::o;78913:445::-;3568:22;:20;:22::i;:::-;48305:26:::1;:24;:26::i;:::-;79108:10:::2;48500:30;48519:10;48500:18;:30::i;:::-;79170:24:::3;79139:27;79155:10;79139:15;:27::i;:::-;:55;;;;;;;;:::i;:::-;;;79131:89;;;::::0;-1:-1:-1;;;79131:89:0;;18709:2:1;79131:89:0::3;::::0;::::3;18691:21:1::0;18748:2;18728:18;;;18721:30;-1:-1:-1;;;18767:18:1;;;18760:51;18828:18;;79131:89:0::3;18507:345:1::0;79131:89:0::3;79281:69;79295:10;79307:16;79325:11;79338;79281:13;:69::i;:::-;48342:1:::2;78913:445:::0;;;:::o;81787:1981::-;3568:22;:20;:22::i;:::-;48305:26:::1;:24;:26::i;:::-;81947:20:::2;81970:15;:13;:15::i;:::-;-1:-1:-1::0;;;;;81970:28:0::2;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;81947:53;;82021:30;82040:10;82021:18;:30::i;:::-;82013:78;;;::::0;-1:-1:-1;;;82013:78:0;;19059:2:1;82013:78:0::2;::::0;::::2;19041:21:1::0;19098:2;19078:18;;;19071:30;19137:34;19117:18;;;19110:62;-1:-1:-1;;;19188:18:1;;;19181:33;19231:19;;82013:78:0::2;18857:399:1::0;82013:78:0::2;82136:10;82124:23;::::0;;;:11:::2;:23;::::0;;;;:39;:55;::::2;;82102:159;;;::::0;-1:-1:-1;;;82102:159:0;;19463:2:1;82102:159:0::2;::::0;::::2;19445:21:1::0;19502:2;19482:18;;;19475:30;19541:34;19521:18;;;19514:62;-1:-1:-1;;;19592:18:1;;;19585:52;19654:19;;82102:159:0::2;19261:418:1::0;82102:159:0::2;82309:10;82274:20;82297:23:::0;;;:11:::2;:23;::::0;;;;;;;82372:36;;;:22:::2;::::0;::::2;:36:::0;;;;;;82505:11:::2;::::0;;::::2;::::0;82518:10:::2;::::0;;::::2;::::0;35379:32;;;:45;;;;35435:31;;:43;83006:28:::2;::::0;::::2;::::0;83049:30;;::::2;83045:136;;;83118:39;::::0;;;:22:::2;::::0;::::2;:39;::::0;;;;:50;35807:32;;83096:73:::2;83403:20;83426:8;:6;:8::i;:::-;83448:23:::0;;83473:28:::2;::::0;83426:76:::2;::::0;-1:-1:-1;;;83426:76:0;;::::2;::::0;::::2;5457:25:1::0;;;;5498:18;;;5491:34;-1:-1:-1;;;;;83426:21:0;;;::::2;::::0;::::2;::::0;5430:18:1;;83426:76:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83403:99;;83515:93;83543:10;83555:12;83569;83583:11;83596;83515:27;:93::i;:::-;83678:32:::0;;;83728::::2;::::0;4329:25:1;;;83735:10:0::2;::::0;83728:32:::2;::::0;4317:2:1;4302:18;83728:32:0::2;;;;;;;;81936:1832;;;;;81787:1981:::0;;:::o;92766:117::-;92850:25;;-1:-1:-1;;;92850:25:0;;:14;:25;;;4329::1;92823:7:0;;92850:23;;;;4302:18:1;;92850:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;85572:228::-;85640:16;85673:35;85696:11;85673:22;:35::i;:::-;85669:75;;;-1:-1:-1;85717:27:0;;85572:228;-1:-1:-1;85572:228:0:o;85669:75::-;-1:-1:-1;85762:30:0;;85572:228;-1:-1:-1;85572:228:0:o;3980:168::-;3303:17;:15;:17::i;:::-;4059:10:::1;:37:::0;;-1:-1:-1;;;;;;4059:37:0::1;-1:-1:-1::0;;;;;4059:37:0;::::1;::::0;;::::1;::::0;;;4114:26:::1;::::0;3468:51:1;;;4114:26:0::1;::::0;3456:2:1;3441:18;4114:26:0::1;3322:203:1::0;76126:1870:0;3568:22;:20;:22::i;:::-;48305:26:::1;:24;:26::i;:::-;76312:10:::2;48500:30;48519:10;48500:18;:30::i;:::-;76374:22:::3;76343:27;76359:10;76343:15;:27::i;:::-;:53;;;;;;;;:::i;:::-;;76335:87;;;::::0;-1:-1:-1;;;76335:87:0;;18709:2:1;76335:87:0::3;::::0;::::3;18691:21:1::0;18748:2;18728:18;;;18721:30;-1:-1:-1;;;18767:18:1;;;18760:51;18828:18;;76335:87:0::3;18507:345:1::0;76335:87:0::3;76470:10;76435:21;76459:22:::0;;;:10:::3;:22;::::0;;;;76502:11;76494:60:::3;;;::::0;-1:-1:-1;;;76494:60:0;;19886:2:1;76494:60:0::3;::::0;::::3;19868:21:1::0;19925:2;19905:18;;;19898:30;19964:34;19944:18;;;19937:62;-1:-1:-1;;;20015:18:1;;;20008:34;20059:19;;76494:60:0::3;19684:400:1::0;76494:60:0::3;76584:16:::0;;76573:27;::::3;;76565:76;;;::::0;-1:-1:-1;;;76565:76:0;;20291:2:1;76565:76:0::3;::::0;::::3;20273:21:1::0;20330:2;20310:18;;;20303:30;20369:34;20349:18;;;20342:62;-1:-1:-1;;;20420:18:1;;;20413:34;20464:19;;76565:76:0::3;20089:400:1::0;76565:76:0::3;76680:19;::::0;::::3;::::0;-1:-1:-1;;;;;76680:19:0::3;76654:23;76733:15;:13;:15::i;:::-;-1:-1:-1::0;;;;;76733:28:0::3;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76815:15;::::0;76710:53;;-1:-1:-1;76774:21:0::3;::::0;76798:33:::3;::::0;76710:53;;76815:15:::3;;76798:16;:33::i;:::-;76868:23;::::0;::::3;::::0;76980:64:::3;::::0;;;;::::3;::::0;;;;;::::3;::::0;;::::3;::::0;;;76842:23:::3;76942:35:::0;;;:18:::3;::::0;::::3;:35:::0;;;;;;:102;;;;;;::::3;::::0;;::::3;::::0;76774:57;;-1:-1:-1;76868:23:0;77130:22:::3;::::0;76868:23;;77130:19:::3;:22::i;:::-;77104:23;::::0;::::3;:48:::0;77229:16;;:29:::3;::::0;77250:7;77229:20:::3;:29::i;:::-;77210:48:::0;;;77271:424:::3;;77405:19;::::0;::::3;:32:::0;;-1:-1:-1;;;;;;77405:32:0::3;::::0;;-1:-1:-1;77545:14:0::3;::::0;;::::3;:18:::0;;;;77584:35:::3;::::0;-1:-1:-1;;;77584:35:0;;:14:::3;:35:::0;;::::3;12902:25:1::0;;;;77608:10:0::3;12943:18:1::0;;;12936:60;77584:23:0::3;::::0;::::3;::::0;12875:18:1;;77584:35:0::3;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;77580:104;;;77640:28;77657:10;77640:16;:28::i;:::-;77824:70;77843:15;77860:7;77869:11;77882;77824:18;:70::i;:::-;77912:76;::::0;;12576:25:1;;;12632:2;12617:18;;12610:34;;;12660:18;;;12653:34;;;77936:10:0::3;::::0;-1:-1:-1;;;;;77912:76:0;::::3;::::0;::::3;::::0;12564:2:1;12549:18;77912:76:0::3;;;;;;;76324:1672;;;;;48342:1:::2;76126:1870:::0;;;:::o;84099:326::-;84181:7;84273:16;84292:15;:13;:15::i;:::-;-1:-1:-1;;;;;84292:28:0;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;84273:49;;84334:13;84353:41;84373:10;84385:8;84353:19;:41::i;:::-;-1:-1:-1;84333:61:0;84099:326;-1:-1:-1;;;;;84099:326:0:o;85245:146::-;-1:-1:-1;;;;;85344:23:0;85317:7;85344:23;;;:10;:23;;;;;;;;:39;;;85245:146::o;52996:629::-;3568:22;:20;:22::i;:::-;48305:26:::1;:24;:26::i;:::-;53170:10:::2;48500:30;48519:10;48500:18;:30::i;:::-;-1:-1:-1::0;;;;;53206:24:0;::::3;53198:54;;;::::0;-1:-1:-1;;;53198:54:0;;20696:2:1;53198:54:0::3;::::0;::::3;20678:21:1::0;20735:2;20715:18;;;20708:30;-1:-1:-1;;;20754:18:1;;;20747:47;20811:18;;53198:54:0::3;20494:341:1::0;53198:54:0::3;53289:10;53263:12;53278:22:::0;;;:10:::3;:22;::::0;;;;:27:::3;;::::0;53324:15;;::::3;;53316:57;;;::::0;-1:-1:-1;;;53316:57:0;;21042:2:1;53316:57:0::3;::::0;::::3;21024:21:1::0;21081:2;21061:18;;;21054:30;21120:31;21100:18;;;21093:59;21169:18;;53316:57:0::3;20840:353:1::0;53316:57:0::3;53414:17;:4:::0;53423:7;53414:8:::3;:17::i;:::-;53395:10;53384:22;::::0;;;:10:::3;:22;::::0;;;;:27:::3;;:47:::0;53506:8:::3;:6;:8::i;:::-;:48;::::0;-1:-1:-1;;;53506:48:0;;-1:-1:-1;;;;;13481:32:1;;;53506:48:0::3;::::0;::::3;13463:51:1::0;13530:18;;;13523:34;;;53506:27:0;;;::::3;::::0;::::3;::::0;13436:18:1;;53506:48:0::3;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;-1:-1:-1::0;;53572:45:0::3;::::0;;-1:-1:-1;;;;;13481:32:1;;13463:51;;13545:2;13530:18;;13523:34;;;53585:10:0::3;::::0;-1:-1:-1;53572:45:0::3;::::0;-1:-1:-1;13436:18:1;53572:45:0::3;;;;;;;53187:438;48342:1:::2;52996:629:::0;;:::o;50654:146::-;50718:74;50731:7;50740:3;50753:1;50765;50777;50789;50718:12;:74::i;51282:126::-;51344:56;51359:16;51385:1;51397;51344:14;:56::i;65492:3758::-;3568:22;:20;:22::i;:::-;48305:26:::1;:24;:26::i;:::-;65955::::2;65974:6;65955:18;:26::i;:::-;-1:-1:-1::0;;;;;66016:18:0;::::2;65992:21;66016:18:::0;;;:10:::2;:18;::::0;;;;;66070:15:::2;:13;:15::i;:::-;-1:-1:-1::0;;;;;66070:28:0::2;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66242:19;::::0;;::::2;::::0;66336:16;;66047:53;;-1:-1:-1;66169:7:0;;-1:-1:-1;;;;;66242:19:0;;::::2;::::0;66369:23:::2;66385:6;66369:15;:23::i;:::-;:51;;;;;;;;:::i;:::-;;66365:1572;;;66627:19;:12:::0;66644:1:::2;66627:16;:19::i;:::-;66610:14;::::0;::::2;:36:::0;66365:1572:::2;;;66822:1;66800:19;:23;:49;;;;;66846:3;-1:-1:-1::0;;;;;66827:22:0::2;:15;-1:-1:-1::0;;;;;66827:22:0::2;;;66800:49;66796:1141;;;66956:10;-1:-1:-1::0;;;;;66956:20:0;::::2;;::::0;:50:::2;;;66994:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;66980:26:0::2;:10;-1:-1:-1::0;;;;;66980:26:0::2;;66956:50;66948:77;;;::::0;-1:-1:-1;;;66948:77:0;;21982:2:1;66948:77:0::2;::::0;::::2;21964:21:1::0;22021:2;22001:18;;;21994:30;-1:-1:-1;;;22040:18:1;;;22033:44;22094:18;;66948:77:0::2;21780:338:1::0;66948:77:0::2;67442:30;67465:6;67442:22;:30::i;:::-;67441:31;67433:105;;;::::0;-1:-1:-1;;;67433:105:0;;22325:2:1;67433:105:0::2;::::0;::::2;22307:21:1::0;22364:2;22344:18;;;22337:30;22403:34;22383:18;;;22376:62;22474:31;22454:18;;;22447:59;22523:19;;67433:105:0::2;22123:425:1::0;67433:105:0::2;67636:19;:12:::0;67653:1:::2;67636:16;:19::i;:::-;67619:14;::::0;::::2;:36:::0;67763:41:::2;:16:::0;67784:19;67763:20:::2;:41::i;:::-;67744:60;;67821:104;67840:15;67857:19;67878:22;67902;67821:18;:104::i;:::-;-1:-1:-1::0;;;;;67997:16:0;::::2;67964:30;67997:16:::0;;;:11:::2;:16;::::0;;;;;;;68065:46;;;:32:::2;::::0;;::::2;:46:::0;;;;;68130:31;;::::2;::::0;68126:219:::2;;68221:63;68243:11;68256;:27;;;68221:21;:63::i;:::-;:108;;::::0;68187:31:::2;::::0;::::2;:142:::0;68126:219:::2;68363:28;::::0;::::2;::::0;68359:207:::2;;68448:60;68470:11;68483;:24;;;68448:21;:60::i;:::-;:102;;::::0;68417:28:::2;::::0;::::2;:133:::0;68359:207:::2;67949:628;;68683:1;68664:16;:20;68656:73;;;::::0;-1:-1:-1;;;68656:73:0;;22755:2:1;68656:73:0::2;::::0;::::2;22737:21:1::0;22794:2;22774:18;;;22767:30;22833:34;22813:18;;;22806:62;-1:-1:-1;;;22884:18:1;;;22877:38;22932:19;;68656:73:0::2;22553:404:1::0;68656:73:0::2;68768:19;::::0;::::2;:25:::0;;-1:-1:-1;;;;;;68768:25:0::2;-1:-1:-1::0;;;;;68768:25:0;::::2;;::::0;;68856:32:::2;:19:::0;68880:7;68856:23:::2;:32::i;:::-;68837:51:::0;;68901:91:::2;68920:3:::0;68925:16;68943:23;68968;68901:18:::2;:91::i;:::-;69009:11:::0;;69005:159:::2;;69084:15;:13;:15::i;:::-;-1:-1:-1::0;;;;;69084:28:0::2;;69113:10;69133:8;:6;:8::i;:::-;69084:68;::::0;-1:-1:-1;;;;;;69084:68:0::2;::::0;;;;;;-1:-1:-1;;;;;23220:15:1;;;69084:68:0::2;::::0;::::2;23202:34:1::0;23272:15;;23252:18;;;23245:43;23304:18;;;23297:34;;;23137:18;;69084:68:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;69005:159;69208:6;-1:-1:-1::0;;;;;69181:61:0::2;69191:15;-1:-1:-1::0;;;;;69181:61:0::2;69186:3;-1:-1:-1::0;;;;;69181:61:0::2;;69216:7;69225:3;:16;;;69181:61;;;;;;5457:25:1::0;;;5513:2;5498:18;;5491:34;5445:2;5430:18;;5283:248;69181:61:0::2;;;;;;;;65814:3436;;;;;65492:3758:::0;;;;;;;:::o;49329:187::-;3434:22;:20;:22::i;:::-;49422:15:::1;:34:::0;;::::1;::::0;::::1;-1:-1:-1::0;;49422:34:0;;::::1;;::::0;;49474::::1;::::0;::::1;::::0;::::1;::::0;23544:2:1;23526:21;;;23583:2;23563:18;;;23556:30;-1:-1:-1;;;23617:2:1;23602:18;;23595:45;23672:2;23657:18;;23342:339;84736:323:0;84817:7;84909:16;84928:15;:13;:15::i;:::-;-1:-1:-1;;;;;84928:28:0;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;84909:49;;84972:12;84988:41;85008:10;85020:8;84988:19;:41::i;:::-;84969:60;84736:323;-1:-1:-1;;;;;;84736:323:0:o;4442:113::-;4507:10;;;;;;;;-1:-1:-1;;;;;4507:10:0;-1:-1:-1;;;;;4507:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4506:20;4498:49;;;;-1:-1:-1;;;4498:49:0;;23888:2:1;4498:49:0;;;23870:21:1;23927:2;23907:18;;;23900:30;-1:-1:-1;;;23946:18:1;;;23939:46;24002:18;;4498:49:0;23686:340:1;116748:155:0;116817:15;:13;:15::i;:::-;-1:-1:-1;;;;;116817:39:0;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;116809:86;;;;-1:-1:-1;;;116809:86:0;;24233:2:1;116809:86:0;;;24215:21:1;;;24252:18;;;24245:30;24311:34;24291:18;;;24284:62;24363:18;;116809:86:0;24031:356:1;116911:343:0;116979:20;117002:15;:13;:15::i;:::-;-1:-1:-1;;;;;117002:28:0;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;117068:22:0;;117043;117068;;;:10;:22;;;;;:37;;;116979:53;;-1:-1:-1;117120:29:0;;;117116:131;;;117166:69;117194:10;117206:12;117220:14;117166:27;:69::i;:::-;116968:286;;116911:343;:::o;116074:156::-;116122:14;116171:10;;:50;;-1:-1:-1;;;116171:50:0;;116194:26;116171:50;;;4329:25:1;-1:-1:-1;;;;;116171:10:0;;;;:22;;4302:18:1;;116171:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11430:98;11488:7;11515:5;11519:1;11515;:5;:::i;114329:800::-;-1:-1:-1;;;;;114527:22:0;;114503:21;114527:22;;;:10;:22;;;;;;;;114589:36;;;:18;;;:36;;;;;;114646:50;114538:10;114608:16;114646:20;:50::i;:::-;114638:88;;;;-1:-1:-1;;;114638:88:0;;15100:2:1;114638:88:0;;;15082:21:1;15139:2;15119:18;;;15112:30;-1:-1:-1;;;15158:18:1;;;15151:55;15223:18;;114638:88:0;14898:349:1;114638:88:0;114756:11;;114844:16;;:28;;114756:11;114844:20;:28::i;:::-;114825:47;;:16;114916:36;;;:18;;;:36;;;;;114909:43;;;;;;114984:19;;;;114965:73;;-1:-1:-1;;;;;114984:19:0;115005:6;115013:11;115026;114965:18;:73::i;:::-;115063:19;;;;115056:65;;;5457:25:1;;;5513:2;5498:18;;5491:34;;;-1:-1:-1;;;;;115056:65:0;;;;115063:19;;115056:65;;5430:18:1;115056:65:0;;;;;;;114492:637;;;114329:800;;;;:::o;11811:98::-;11869:7;11896:5;11900:1;11896;:5;:::i;111252:2477::-;-1:-1:-1;;;;;111431:22:0;;111407:21;111431:22;;;:10;:22;;;;;;111485;:15;111505:1;111485:19;:22::i;:::-;111548:16;;111597:8;;;;111752:19;;;;111464:43;;-1:-1:-1;111548:16:0;;-1:-1:-1;;;;;111752:19:0;:33;111748:1559;;111839:42;111859:10;111871:9;111839:19;:42::i;:::-;112218:19;;;;-1:-1:-1;;;;;112218:19:0;112183:20;112206:32;;;:11;:32;;;;;;;;112297:33;;;:22;;;;:33;;;;;112349:38;;;;111802:79;;-1:-1:-1;111802:79:0;;-1:-1:-1;112206:32:0;112345:352;;112439:17;;112479:27;;;112475:207;;;112572:41;112594:1;112597:15;112572:21;:41::i;:::-;:90;;;112531:38;;;:131;112475:207;112394:303;112345:352;112715:35;;;;112711:305;;112799:14;;;;112836:24;;;112832:169;;;112923:38;112945:1;112948:12;112923:21;:38::i;:::-;:58;;;112885:35;;;:96;112832:169;112757:259;112711:305;113036:19;;;;-1:-1:-1;;;;;113036:33:0;;;:19;;:33;113032:264;;;113109:1;113090:16;;;:20;;;113129:19;;;:23;113032:264;111787:1520;;111748:1559;113354:19;;;;113437:16;;-1:-1:-1;;;;;113324:230:0;;;;113354:19;;113324:230;;113413:41;;:19;;:23;:41::i;:::-;113485:8;;;;113469:25;;:11;;:15;:25::i;:::-;113324:230;;;25018:25:1;;;25074:2;25059:18;;25052:34;;;;25102:18;;25095:34;;;25160:2;25145:18;;25138:34;;;25005:3;24990:19;113324:230:0;;;;;;;113567:18;;;:30;;;;113650:38;;-1:-1:-1;113699:8:0;;:22;;;;-1:-1:-1;;111252:2477:0:o;116587:153::-;116659:10;;:45;;-1:-1:-1;;;116659:45:0;;116682:21;116659:45;;;4329:25:1;-1:-1:-1;;;;;116659:10:0;;;;:22;;4302:18:1;;116659:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;116645:59:0;:10;-1:-1:-1;;;;;116645:59:0;;116637:95;;;;-1:-1:-1;;;116637:95:0;;25385:2:1;116637:95:0;;;25367:21:1;25424:2;25404:18;;;25397:30;25463:25;25443:18;;;25436:53;25506:18;;116637:95:0;25183:347:1;31645:148:0;31719:7;31746:39;30501:7;31746:21;:7;31758:8;31746:11;:21::i;:::-;:25;;:39::i;107612:893::-;108142:34;;-1:-1:-1;;;108142:34:0;;:14;:34;;;12902:25:1;-1:-1:-1;;;;;12963:32:1;;12943:18;;;12936:60;108142:21:0;;;;12875:18:1;;108142:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;108215:64;108245:33;108266:11;108245:20;:33::i;:::-;108215:25;;;:29;:64::i;:::-;108187:25;:92;108290:25;108318:37;108353:1;108318:15;:13;:15::i;:37::-;-1:-1:-1;;;;;108366:24:0;;;;;;:11;:24;;;;;;;:42;;:62;;;108444:53;108290:65;;-1:-1:-1;108366:24:0;108444:53;;;;108290:65;4329:25:1;;4317:2;4302:18;;4183:177;108444:53:0;;;;;;;;107668:837;107612:893;:::o;115544:128::-;115585:7;115620:10;;:43;;-1:-1:-1;;;115620:43:0;;115643:19;115620:43;;;4329:25:1;-1:-1:-1;;;;;115620:10:0;;;;:22;;4302:18:1;;115620:43:0;4183:177:1;105281:2240:0;105534:25;;105576:23;;-1:-1:-1;;;105576:23:0;;:14;:23;;;4329:25:1;105576:21:0;;;;4302:18:1;;105576:23:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;105572:1339;;;105641:24;;-1:-1:-1;;;105641:24:0;;:14;:24;;;4329:25:1;105616:22:0;;105641;;;;4302:18:1;;105641:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;105616:49;;105680:17;105700:36;105721:14;105700:20;:36::i;:::-;105680:56;;105974:9;105959:11;:24;105955:71;;106004:7;;;;;105955:71;106609:37;;-1:-1:-1;;;106609:37:0;;:14;:37;;;12902:25:1;-1:-1:-1;;;;;12963:32:1;;12943:18;;;12936:60;106609:21:0;;;;12875:18:1;;106609:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;106661:27:0;;;;;;:11;:27;;;;;:45;;:64;;;-1:-1:-1;106775:47:0;:32;106812:9;106775:36;:47::i;:::-;106740:82;;106866:14;-1:-1:-1;;;;;106844:55:0;;106882:16;106844:55;;;;4329:25:1;;4317:2;4302:18;;4183:177;106844:55:0;;;;;;;;105601:1310;;105572:1339;106923:73;;-1:-1:-1;;;106923:73:0;;:21;;;;:73;;:14;;106945:11;;106958;;106971;;106984;;106923:73;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;107042:49;107079:11;107042:32;:36;;:49;;;;:::i;:::-;-1:-1:-1;;;;;107125:24:0;;107102:20;107125:24;;;:11;:24;;;;;;;;107160:28;;;:47;;;107218:17;;;:36;;;-1:-1:-1;;107265:19:0;;;:38;107314:40;;;:22;;;:40;;;;;;35807:32;;;107007:84;;-1:-1:-1;107387:25:0;:60;;;107463:50;;4329:25:1;;;-1:-1:-1;;;;;107463:50:0;;;;;4317:2:1;4302:18;107463:50:0;4183:177:1;116238:165:0;116314:10;;:49;;-1:-1:-1;;;116314:49:0;;116337:25;116314:49;;;4329:25:1;-1:-1:-1;;;;;116314:10:0;;;;:22;;4302:18:1;;116314:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;116300:63:0;:10;-1:-1:-1;;;;;116300:63:0;;116292:103;;;;-1:-1:-1;;;116292:103:0;;26300:2:1;116292:103:0;;;26282:21:1;26339:2;26319:18;;;26312:30;26378:29;26358:18;;;26351:57;26425:18;;116292:103:0;26098:351:1;96023:987:0;96158:29;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;96158:29:0;96212:42;96234:11;96247:6;96212:21;:42::i;:::-;96293:27;;96439;;;;96205:49;;-1:-1:-1;96293:27:0;96439:32;:60;;;;;96493:6;96475:15;:24;96439:60;96435:197;;;96546:51;96568:11;96581:15;96546:21;:51::i;:::-;:74;;;;;96516:27;;;:104;96435:197;96667:24;;;;96801;;;;:29;:54;;;;;96849:6;96834:12;:21;96801:54;96797:182;;;96899:48;96921:11;96934:12;96899:21;:48::i;:::-;:68;;;;;96872:24;;;:95;96797:182;96991:11;;96023:987;;;;:::o;33048:226::-;33176:7;33203:63;32431:6;33203:45;33215:32;33226:8;33236:10;33215;:32::i;:::-;33203:7;;:11;:45::i;36361:1023::-;36583:37;;;;36668:40;;;;36549:31;;36668:150;;36785:33;36813:1;36816;36785:27;:33::i;:::-;36668:150;;;36729:17;:40;;;36668:150;36631:187;;36918:12;:32;;;36954:1;36918:37;36914:270;;;37007:144;37053:83;37077:26;37105:5;37112:12;:23;;;37053;:83::i;:::-;37007:23;;:27;:144::i;:::-;36972:12;:32;;:179;;;;37166:7;;36361:1023;;;:::o;36914:270::-;37231:145;37282:83;37306:26;37334:5;37341:12;:23;;;37282;:83::i;:::-;37231:32;;;;;:36;:145::i;4294:140::-;4372:10;;;;;;;;-1:-1:-1;;;;;4372:10:0;-1:-1:-1;;;;;4372:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;4358:32:0;:10;-1:-1:-1;;;;;4358:32:0;;4350:76;;;;-1:-1:-1;;;4350:76:0;;26656:2:1;4350:76:0;;;26638:21:1;26695:2;26675:18;;;26668:30;26734:33;26714:18;;;26707:61;26785:18;;4350:76:0;26454:355:1;116411:168:0;116488:10;;:50;;-1:-1:-1;;;116488:50:0;;116511:26;116488:50;;;4329:25:1;-1:-1:-1;;;;;116488:10:0;;;;:22;;4302:18:1;;116488:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;116474:64:0;:10;-1:-1:-1;;;;;116474:64:0;;116466:105;;;;-1:-1:-1;;;116466:105:0;;27016:2:1;116466:105:0;;;26998:21:1;27055:2;27035:18;;;27028:30;27094;27074:18;;;27067:58;27142:18;;116466:105:0;26814:352:1;109043:1842:0;-1:-1:-1;;;;;109272:24:0;;109249:20;109272:24;;;:11;:24;;;;;;;;109348:30;;;:22;;;:30;;;;;109458:17;;109272:24;;109348:30;;109433:43;;109272:24;;109433:21;:43::i;:::-;109389:87;;109517:1;:19;;;109489:1;:25;;:47;;;;109549:35;109587:60;109604:8;109614:12;:32;;;109587:16;:60::i;:::-;109549:98;-1:-1:-1;109658:25:0;109686:41;:8;109549:98;109686:12;:41::i;:::-;109658:69;;109814:36;109853:144;109891:17;109923:1;:25;;;109963:12;:23;;;109853;:144::i;:::-;109814:183;;110123:86;110181:27;110123:53;110147:28;110123:1;:19;;;:23;;:53;;;;:::i;:86::-;110101:19;;;:108;110664:78;:12;110706:16;110724:17;110664:41;:78::i;:::-;110810:67;110829:11;110842:8;110852:11;110865;110810:18;:67::i;:::-;109238:1647;;;;;;109043:1842;;;;;:::o;4156:130::-;4237:10;;-1:-1:-1;;;;;4237:10:0;4215;:33;4207:71;;;;-1:-1:-1;;;4207:71:0;;27373:2:1;4207:71:0;;;27355:21:1;27412:2;27392:18;;;27385:30;27451:27;27431:18;;;27424:55;27496:18;;4207:71:0;27171:349:1;103315:1578:0;103488:34;;-1:-1:-1;;;103488:34:0;;:14;:34;;;12902:25:1;-1:-1:-1;;;;;12963:32:1;;12943:18;;;12936:60;103488:23:0;;;;12875:18:1;;103488:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;103484:1246;;;103539:17;103559:31;103580:9;103559:20;:31::i;:::-;103539:51;-1:-1:-1;103605:16:0;103624:22;103539:51;103638:7;103624:13;:22::i;:::-;103605:41;;103661:17;103681:15;:13;:15::i;:::-;-1:-1:-1;;;;;103681:28:0;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;103661:50;-1:-1:-1;103726:17:0;103746:16;103661:50;103760:1;103746:13;:16::i;:::-;103779:71;;-1:-1:-1;;;103779:71:0;;103726:36;;-1:-1:-1;103779:24:0;;;;:71;;:14;;103804:9;;103815:8;;103825:11;;103838;;103779:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;103893:25:0;;:38;;-1:-1:-1;103893:25:0;-1:-1:-1;103923:7:0;103893:29;:38::i;:::-;103865:25;:66;-1:-1:-1;;;;;103969:22:0;;103946:20;103969:22;;;:11;:22;;;;;;;;104465:28;;;;:40;-1:-1:-1;104461:134:0;;;104526:33;;;;:22;;;:33;;;;;35807:32;;;104526:53;104611:28;;;:40;;;104666:33;;;;:22;;:33;;;;;35807:32;;;;-1:-1:-1;;103484:1246:0;-1:-1:-1;;;;;104835:21:0;;;;;;:10;:21;;;;;;;;:37;;:50;;104877:7;104835:41;:50::i;:::-;-1:-1:-1;;;;;104795:21:0;;;;;;;:10;:21;;;;;;;;:37;:90;;;;-1:-1:-1;;;103315:1578:0:o;99529:1260::-;-1:-1:-1;;;;;99716:22:0;;;99647:13;99716:22;;;:10;:22;;;;;;;;99784:19;;;;;;;99772:32;;:11;:32;;;;;99784:19;99824:8;;;;99851:16;;99901:18;;;;99851:16;;99824:8;;99716:22;;99772:32;99901:25;;:18;:22;:25::i;:::-;99960:19;;;;99880:46;;-1:-1:-1;;;;;;99960:19:0;;;;100010:26;;;;100140:23;;;100136:149;;100196:77;100228:1;100231:17;:10;100246:1;100231:14;:17::i;:::-;100250:9;100261:5;100268:4;100196:31;:77::i;:::-;100180:93;;-1:-1:-1;100180:93:0;-1:-1:-1;100136:149:0;100622:12;100618:131;;;100669:19;;;;100659:30;;:5;;:9;:30::i;:::-;100651:38;;100711:26;100720:1;:16;;;100711:4;:8;;:26;;;;:::i;:::-;100704:33;;100618:131;100761:20;;;;;99529:1260;;;;;:::o;115811:127::-;115856:7;115883:10;;:47;;-1:-1:-1;;;115883:47:0;;115906:23;115883:47;;;4329:25:1;-1:-1:-1;;;;;115883:10:0;;;;:22;;4302:18:1;;115883:47:0;4183:177:1;95255:399:0;95384:29;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95384:29:0;95461:40;;;;:32;;;;:40;;;;;;;:63;;;;95431:27;;;:93;95562:40;;;;;;;:60;;;;;95535:24;;;:87;95431:27;95255:399::o;101052:1998::-;101225:33;101248:9;101225:22;:33::i;:::-;101221:1670;;;101275:17;101295:31;101316:9;101295:20;:31::i;:::-;101275:51;-1:-1:-1;101341:16:0;101360:22;101275:51;101374:7;101360:13;:22::i;:::-;101341:41;;101397:17;101417:15;:13;:15::i;:::-;-1:-1:-1;;;;;101417:28:0;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;101397:50;-1:-1:-1;101462:17:0;101482:16;101397:50;101496:1;101482:13;:16::i;:::-;101610:34;;-1:-1:-1;;;101610:34:0;;:14;:34;;;12902:25:1;-1:-1:-1;;;;;12963:32:1;;12943:18;;;12936:60;101462:36:0;;-1:-1:-1;101610:23:0;;;;12875:18:1;;101610:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;101606:1274;;;101665:71;;-1:-1:-1;;;101665:71:0;;:24;;;;:71;;:14;;101690:9;;101701:8;;101711:11;;101724;;101665:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;101783:25:0;;:38;;-1:-1:-1;101783:25:0;-1:-1:-1;101813:7:0;101783:29;:38::i;:::-;101755:25;:66;-1:-1:-1;;;;;101863:22:0;;101840:20;101863:22;;;:11;:22;;;;;;;;102379:28;;;;:40;-1:-1:-1;102375:142:0;;;102444:33;;;;:22;;;:33;;;;;35807:32;;;102444:53;102537:33;;;;:22;;;:33;;;;;35807:32;;;102608:28;;:40;;;101606:1274;;;102788:76;102807:9;102818:8;102828:9;102839:11;102852;102788:18;:76::i;:::-;101260:1631;;;;101221:1670;-1:-1:-1;;;;;102992:21:0;;;;;;:10;:21;;;;;;;;:37;;:50;;103034:7;102992:41;:50::i;115266:156::-;115314:14;115363:10;;:50;;-1:-1:-1;;;115363:50:0;;115386:26;115363:50;;;4329:25:1;-1:-1:-1;;;;;115363:10:0;;;;:22;;4302:18:1;;115363:50:0;4183:177:1;12168:98:0;12226:7;12253:5;12257:1;12253;:5;:::i;12567:98::-;12625:7;12652:5;12656:1;12652;:5;:::i;33959:158::-;34040:7;34067:42;34098:10;34067:26;:8;32431:6;34067:12;:26::i;37751:582::-;37945:34;37982:17;:40;;;38026:1;37982:45;;:150;;38099:33;38127:1;38130;38099:27;:33::i;:::-;37982:150;;;38043:17;:40;;;37982:150;37945:187;;38183:142;38228:86;38252:26;38280:8;38290:12;:23;;;38228;:86::i;:::-;38183:26;;:30;:142::i;:::-;38145:12;:35;;:180;;;;37934:399;37751:582;;;:::o;97708:1459::-;97927:14;97943:13;98012:34;98049:47;98071:11;98084;98049:21;:47::i;:::-;98012:84;;98225:9;:32;;;98261:1;98225:37;98221:138;;;98314:33;98342:1;98345;98314:27;:33::i;:::-;98279:32;;;:68;98221:138;98412:32;98447:51;98475:11;98488:9;98447:27;:51::i;:::-;98412:86;;98625:7;:30;;;98659:1;98625:35;98621:134;;;98710:33;98738:1;98741;98710:27;:33::i;:::-;98677:30;;;:66;98621:134;98775:230;98799:195;98841:6;98866:62;98898:9;:29;;;98866:7;:27;;;:31;;:62;;;;:::i;:::-;98947:9;:32;;;98799:23;:195::i;:::-;98775:5;;:9;:230::i;:::-;98767:238;;99027:97;99051:6;99059:7;:30;;;99091:9;:32;;;99027:23;:97::i;:::-;99018:106;;99137:22;;97708:1459;;;;;;;;:::o;14:131:1:-;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;150:598;236:6;244;252;260;313:3;301:9;292:7;288:23;284:33;281:53;;;330:1;327;320:12;281:53;369:9;356:23;388:31;413:5;388:31;:::i;:::-;438:5;-1:-1:-1;490:2:1;475:18;;462:32;;-1:-1:-1;546:2:1;531:18;;518:32;559:33;518:32;559:33;:::i;:::-;611:7;-1:-1:-1;670:2:1;655:18;;642:32;683:33;642:32;683:33;:::i;:::-;150:598;;;;-1:-1:-1;150:598:1;;-1:-1:-1;;150:598:1:o;753:882::-;857:6;865;873;881;889;897;950:3;938:9;929:7;925:23;921:33;918:53;;;967:1;964;957:12;918:53;1006:9;993:23;1025:31;1050:5;1025:31;:::i;:::-;1075:5;-1:-1:-1;1127:2:1;1112:18;;1099:32;;-1:-1:-1;1183:2:1;1168:18;;1155:32;1196:33;1155:32;1196:33;:::i;:::-;1248:7;-1:-1:-1;1307:2:1;1292:18;;1279:32;1320:33;1279:32;1320:33;:::i;:::-;1372:7;-1:-1:-1;1431:3:1;1416:19;;1403:33;1445;1403;1445;:::i;:::-;1497:7;-1:-1:-1;1556:3:1;1541:19;;1528:33;1570;1528;1570;:::i;:::-;1622:7;1612:17;;;753:882;;;;;;;;:::o;1640:247::-;1699:6;1752:2;1740:9;1731:7;1727:23;1723:32;1720:52;;;1768:1;1765;1758:12;1720:52;1807:9;1794:23;1826:31;1851:5;1826:31;:::i;2084:315::-;2152:6;2160;2213:2;2201:9;2192:7;2188:23;2184:32;2181:52;;;2229:1;2226;2219:12;2181:52;2268:9;2255:23;2287:31;2312:5;2287:31;:::i;:::-;2337:5;2389:2;2374:18;;;;2361:32;;-1:-1:-1;;;2084:315:1:o;2404:127::-;2465:10;2460:3;2456:20;2453:1;2446:31;2496:4;2493:1;2486:15;2520:4;2517:1;2510:15;2536:251;2688:2;2673:18;;2721:1;2710:13;;2700:47;;2727:18;;:::i;:::-;2756:25;;;2536:251;:::o;2792:525::-;2878:6;2886;2894;2902;2955:3;2943:9;2934:7;2930:23;2926:33;2923:53;;;2972:1;2969;2962:12;2923:53;3011:9;2998:23;3030:31;3055:5;3030:31;:::i;:::-;3080:5;-1:-1:-1;3137:2:1;3122:18;;3109:32;3150:33;3109:32;3150:33;:::i;:::-;2792:525;;3202:7;;-1:-1:-1;;;;3256:2:1;3241:18;;3228:32;;3307:2;3292:18;3279:32;;2792:525::o;3998:180::-;4057:6;4110:2;4098:9;4089:7;4085:23;4081:32;4078:52;;;4126:1;4123;4116:12;4078:52;-1:-1:-1;4149:23:1;;3998:180;-1:-1:-1;3998:180:1:o;4365:525::-;4451:6;4459;4467;4475;4528:3;4516:9;4507:7;4503:23;4499:33;4496:53;;;4545:1;4542;4535:12;4496:53;4581:9;4568:23;4558:33;;4638:2;4627:9;4623:18;4610:32;4600:42;;4692:2;4681:9;4677:18;4664:32;4705:31;4730:5;4705:31;:::i;4895:383::-;4972:6;4980;4988;5041:2;5029:9;5020:7;5016:23;5012:32;5009:52;;;5057:1;5054;5047:12;5009:52;5096:9;5083:23;5115:31;5140:5;5115:31;:::i;:::-;5165:5;5217:2;5202:18;;5189:32;;-1:-1:-1;5268:2:1;5253:18;;;5240:32;;4895:383;-1:-1:-1;;;4895:383:1:o;5536:248::-;5604:6;5612;5665:2;5653:9;5644:7;5640:23;5636:32;5633:52;;;5681:1;5678;5671:12;5633:52;-1:-1:-1;;5704:23:1;;;5774:2;5759:18;;;5746:32;;-1:-1:-1;5536:248:1:o;6799:882::-;6903:6;6911;6919;6927;6935;6943;6996:3;6984:9;6975:7;6971:23;6967:33;6964:53;;;7013:1;7010;7003:12;6964:53;7049:9;7036:23;7026:33;;7109:2;7098:9;7094:18;7081:32;7122:31;7147:5;7122:31;:::i;:::-;7172:5;-1:-1:-1;7229:2:1;7214:18;;7201:32;7242:33;7201:32;7242:33;:::i;7891:456::-;7968:6;7976;7984;8037:2;8025:9;8016:7;8012:23;8008:32;8005:52;;;8053:1;8050;8043:12;8005:52;8089:9;8076:23;8066:33;;8149:2;8138:9;8134:18;8121:32;8162:31;8187:5;8162:31;:::i;:::-;8212:5;-1:-1:-1;8269:2:1;8254:18;;8241:32;8282:33;8241:32;8282:33;:::i;:::-;8334:7;8324:17;;;7891:456;;;;;:::o;8352:388::-;8420:6;8428;8481:2;8469:9;8460:7;8456:23;8452:32;8449:52;;;8497:1;8494;8487:12;8449:52;8536:9;8523:23;8555:31;8580:5;8555:31;:::i;:::-;8605:5;-1:-1:-1;8662:2:1;8647:18;;8634:32;8675:33;8634:32;8675:33;:::i;:::-;8727:7;8717:17;;;8352:388;;;;;:::o;8745:252::-;8898:2;8883:18;;8931:1;8920:13;;8910:47;;8937:18;;:::i;9968:315::-;10036:6;10044;10097:2;10085:9;10076:7;10072:23;10068:32;10065:52;;;10113:1;10110;10103:12;10065:52;10149:9;10136:23;10126:33;;10209:2;10198:9;10194:18;10181:32;10222:31;10247:5;10222:31;:::i;10288:1024::-;10401:6;10409;10417;10425;10433;10441;10449;10502:3;10490:9;10481:7;10477:23;10473:33;10470:53;;;10519:1;10516;10509:12;10470:53;10555:9;10542:23;10532:33;;10615:2;10604:9;10600:18;10587:32;10628:31;10653:5;10628:31;:::i;:::-;10678:5;-1:-1:-1;10735:2:1;10720:18;;10707:32;10748:33;10707:32;10748:33;:::i;:::-;10800:7;-1:-1:-1;10859:2:1;10844:18;;10831:32;10872:33;10831:32;10872:33;:::i;:::-;10924:7;-1:-1:-1;10983:3:1;10968:19;;10955:33;10997;10955;10997;:::i;:::-;11049:7;-1:-1:-1;11108:3:1;11093:19;;11080:33;11122;11080;11122;:::i;:::-;11174:7;-1:-1:-1;11233:3:1;11218:19;;11205:33;11247;11205;11247;:::i;:::-;11299:7;11289:17;;;10288:1024;;;;;;;;;;:::o;11317:284::-;11375:6;11428:2;11416:9;11407:7;11403:23;11399:32;11396:52;;;11444:1;11441;11434:12;11396:52;11483:9;11470:23;11533:18;11526:5;11522:30;11515:5;11512:41;11502:69;;11567:1;11564;11557:12;12185:184;12255:6;12308:2;12296:9;12287:7;12283:23;12279:32;12276:52;;;12324:1;12321;12314:12;12276:52;-1:-1:-1;12347:16:1;;12185:184;-1:-1:-1;12185:184:1:o;13007:277::-;13074:6;13127:2;13115:9;13106:7;13102:23;13098:32;13095:52;;;13143:1;13140;13133:12;13095:52;13175:9;13169:16;13228:5;13221:13;13214:21;13207:5;13204:32;13194:60;;13250:1;13247;13240:12;14642:251;14712:6;14765:2;14753:9;14744:7;14740:23;14736:32;14733:52;;;14781:1;14778;14771:12;14733:52;14813:9;14807:16;14832:31;14857:5;14832:31;:::i;24392:127::-;24453:10;24448:3;24444:20;24441:1;24434:31;24484:4;24481:1;24474:15;24508:4;24505:1;24498:15;24524:128;24564:3;24595:1;24591:6;24588:1;24585:13;24582:39;;;24601:18;;:::i;:::-;-1:-1:-1;24637:9:1;;24524:128::o;24657:125::-;24697:4;24725:1;24722;24719:8;24716:34;;;24730:18;;:::i;:::-;-1:-1:-1;24767:9:1;;24657:125::o;25535:558::-;25824:25;;;-1:-1:-1;;;;;25923:15:1;;;25918:2;25903:18;;25896:43;25970:2;25955:18;;25948:34;;;;26018:15;;26013:2;25998:18;;25991:43;26071:15;26065:3;26050:19;;26043:44;25811:3;25796:19;;25535:558::o;27525:168::-;27565:7;27631:1;27627;27623:6;27619:14;27616:1;27613:21;27608:1;27601:9;27594:17;27590:45;27587:71;;;27638:18;;:::i;:::-;-1:-1:-1;27678:9:1;;27525:168::o;27698:217::-;27738:1;27764;27754:132;;27808:10;27803:3;27799:20;27796:1;27789:31;27843:4;27840:1;27833:15;27871:4;27868:1;27861:15;27754:132;-1:-1:-1;27900:9:1;;27698:217::o

Metadata Hash

1095d0e196662b6b6626c013501e527e5173a9c7b05e4e37c72c7a82905813ab
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.