Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at fraxscan.com on 2024-06-25
*/

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity =0.8.19 ^0.8.0 ^0.8.19 ^0.8.4 ^0.8.7;

// lib/herdaddy/src/interfaces/IFeeReceiver.sol

interface IFeeReceiver {
    struct Repartition {
        address[] receivers;
        uint256[] fees; // Fee in basis points, where 10,000 basis points = 100%
    }

    function governance() external view returns (address);
    function futureGovernance() external view returns (address);
    function acceptGovernance() external;
    function transferGovernance(address _futureGovernance) external;

    function getRepartition(address rewardToken) external view returns (address[] memory receivers, uint256[] memory fees);
    function setRepartition(address rewardToken, address[] calldata receivers, uint256[] calldata fees) external;
    function setAccumulator(address rewardToken, address _accumulator) external;

    function split(address rewardToken) external;
}

// lib/solady/src/tokens/ERC20.sol

/// @notice Simple ERC20 + EIP-2612 implementation.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)
///
/// @dev Note:
/// The ERC20 standard allows minting and transferring to and from the zero address,
/// minting and transferring zero tokens, as well as self-approvals.
/// For performance, this implementation WILL NOT revert for such actions.
/// Please add any checks with overrides if desired.
abstract contract ERC20 {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The total supply has overflowed.
    error TotalSupplyOverflow();

    /// @dev The allowance has overflowed.
    error AllowanceOverflow();

    /// @dev The allowance has underflowed.
    error AllowanceUnderflow();

    /// @dev Insufficient balance.
    error InsufficientBalance();

    /// @dev Insufficient allowance.
    error InsufficientAllowance();

    /// @dev The permit is invalid.
    error InvalidPermit();

    /// @dev The permit has expired.
    error PermitExpired();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Emitted when `amount` tokens is transferred from `from` to `to`.
    event Transfer(address indexed from, address indexed to, uint256 amount);

    /// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /// @dev `keccak256(bytes("Transfer(address,address,uint256)"))`.
    uint256 private constant _TRANSFER_EVENT_SIGNATURE =
        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;

    /// @dev `keccak256(bytes("Approval(address,address,uint256)"))`.
    uint256 private constant _APPROVAL_EVENT_SIGNATURE =
        0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The storage slot for the total supply.
    uint256 private constant _TOTAL_SUPPLY_SLOT = 0x05345cdf77eb68f44c;

    /// @dev The balance slot of `owner` is given by:
    /// ```
    ///     mstore(0x0c, _BALANCE_SLOT_SEED)
    ///     mstore(0x00, owner)
    ///     let balanceSlot := keccak256(0x0c, 0x20)
    /// ```
    uint256 private constant _BALANCE_SLOT_SEED = 0x87a211a2;

    /// @dev The allowance slot of (`owner`, `spender`) is given by:
    /// ```
    ///     mstore(0x20, spender)
    ///     mstore(0x0c, _ALLOWANCE_SLOT_SEED)
    ///     mstore(0x00, owner)
    ///     let allowanceSlot := keccak256(0x0c, 0x34)
    /// ```
    uint256 private constant _ALLOWANCE_SLOT_SEED = 0x7f5e9f20;

    /// @dev The nonce slot of `owner` is given by:
    /// ```
    ///     mstore(0x0c, _NONCES_SLOT_SEED)
    ///     mstore(0x00, owner)
    ///     let nonceSlot := keccak256(0x0c, 0x20)
    /// ```
    uint256 private constant _NONCES_SLOT_SEED = 0x38377508;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       ERC20 METADATA                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the name of the token.
    function name() public view virtual returns (string memory);

    /// @dev Returns the symbol of the token.
    function symbol() public view virtual returns (string memory);

    /// @dev Returns the decimals places of the token.
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           ERC20                            */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the amount of tokens in existence.
    function totalSupply() public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(_TOTAL_SUPPLY_SLOT)
        }
    }

    /// @dev Returns the amount of tokens owned by `owner`.
    function balanceOf(address owner) public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, owner)
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.
    function allowance(address owner, address spender)
        public
        view
        virtual
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, owner)
            result := sload(keccak256(0x0c, 0x34))
        }
    }

    /// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
    ///
    /// Emits a {Approval} event.
    function approve(address spender, uint256 amount) public virtual returns (bool) {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the allowance slot and store the amount.
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x34), amount)
            // Emit the {Approval} event.
            mstore(0x00, amount)
            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))
        }
        return true;
    }

    /// @dev Atomically increases the allowance granted to `spender` by the caller.
    ///
    /// Emits a {Approval} event.
    function increaseAllowance(address spender, uint256 difference) public virtual returns (bool) {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the allowance slot and load its value.
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, caller())
            let allowanceSlot := keccak256(0x0c, 0x34)
            let allowanceBefore := sload(allowanceSlot)
            // Add to the allowance.
            let allowanceAfter := add(allowanceBefore, difference)
            // Revert upon overflow.
            if lt(allowanceAfter, allowanceBefore) {
                mstore(0x00, 0xf9067066) // `AllowanceOverflow()`.
                revert(0x1c, 0x04)
            }
            // Store the updated allowance.
            sstore(allowanceSlot, allowanceAfter)
            // Emit the {Approval} event.
            mstore(0x00, allowanceAfter)
            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))
        }
        return true;
    }

    /// @dev Atomically decreases the allowance granted to `spender` by the caller.
    ///
    /// Emits a {Approval} event.
    function decreaseAllowance(address spender, uint256 difference) public virtual returns (bool) {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the allowance slot and load its value.
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, caller())
            let allowanceSlot := keccak256(0x0c, 0x34)
            let allowanceBefore := sload(allowanceSlot)
            // Revert if will underflow.
            if lt(allowanceBefore, difference) {
                mstore(0x00, 0x8301ab38) // `AllowanceUnderflow()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated allowance.
            let allowanceAfter := sub(allowanceBefore, difference)
            sstore(allowanceSlot, allowanceAfter)
            // Emit the {Approval} event.
            mstore(0x00, allowanceAfter)
            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))
        }
        return true;
    }

    /// @dev Transfer `amount` tokens from the caller to `to`.
    ///
    /// Requirements:
    /// - `from` must at least have `amount`.
    ///
    /// Emits a {Transfer} event.
    function transfer(address to, uint256 amount) public virtual returns (bool) {
        _beforeTokenTransfer(msg.sender, to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the balance slot and load its value.
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, caller())
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Compute the balance slot of `to`.
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance of `to`.
            // Will not overflow because the sum of all user balances
            // cannot exceed the maximum uint256 value.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, caller(), shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(msg.sender, to, amount);
        return true;
    }

    /// @dev Transfers `amount` tokens from `from` to `to`.
    ///
    /// Note: Does not update the allowance if it is the maximum uint256 value.
    ///
    /// Requirements:
    /// - `from` must at least have `amount`.
    /// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.
    ///
    /// Emits a {Transfer} event.
    function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
        _beforeTokenTransfer(from, to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            let from_ := shl(96, from)
            // Compute the allowance slot and load its value.
            mstore(0x20, caller())
            mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))
            let allowanceSlot := keccak256(0x0c, 0x34)
            let allowance_ := sload(allowanceSlot)
            // If the allowance is not the maximum uint256 value.
            if iszero(eq(allowance_, not(0))) {
                // Revert if the amount to be transferred exceeds the allowance.
                if gt(amount, allowance_) {
                    mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.
                    revert(0x1c, 0x04)
                }
                // Subtract and store the updated allowance.
                sstore(allowanceSlot, sub(allowance_, amount))
            }
            // Compute the balance slot and load its value.
            mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Compute the balance slot of `to`.
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance of `to`.
            // Will not overflow because the sum of all user balances
            // cannot exceed the maximum uint256 value.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(from, to, amount);
        return true;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          EIP-2612                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the current nonce for `owner`.
    /// This value is used to compute the signature for EIP-2612 permit.
    function nonces(address owner) public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the nonce slot and load its value.
            mstore(0x0c, _NONCES_SLOT_SEED)
            mstore(0x00, owner)
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /// @dev Sets `value` as the allowance of `spender` over the tokens of `owner`,
    /// authorized by a signed approval by `owner`.
    ///
    /// Emits a {Approval} event.
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        bytes32 domainSeparator = DOMAIN_SEPARATOR();
        /// @solidity memory-safe-assembly
        assembly {
            // Grab the free memory pointer.
            let m := mload(0x40)
            // Revert if the block timestamp greater than `deadline`.
            if gt(timestamp(), deadline) {
                mstore(0x00, 0x1a15a3cc) // `PermitExpired()`.
                revert(0x1c, 0x04)
            }
            // Clean the upper 96 bits.
            owner := shr(96, shl(96, owner))
            spender := shr(96, shl(96, spender))
            // Compute the nonce slot and load its value.
            mstore(0x0c, _NONCES_SLOT_SEED)
            mstore(0x00, owner)
            let nonceSlot := keccak256(0x0c, 0x20)
            let nonceValue := sload(nonceSlot)
            // Increment and store the updated nonce.
            sstore(nonceSlot, add(nonceValue, 1))
            // Prepare the inner hash.
            // `keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")`.
            // forgefmt: disable-next-item
            mstore(m, 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9)
            mstore(add(m, 0x20), owner)
            mstore(add(m, 0x40), spender)
            mstore(add(m, 0x60), value)
            mstore(add(m, 0x80), nonceValue)
            mstore(add(m, 0xa0), deadline)
            // Prepare the outer hash.
            mstore(0, 0x1901)
            mstore(0x20, domainSeparator)
            mstore(0x40, keccak256(m, 0xc0))
            // Prepare the ecrecover calldata.
            mstore(0, keccak256(0x1e, 0x42))
            mstore(0x20, and(0xff, v))
            mstore(0x40, r)
            mstore(0x60, s)
            pop(staticcall(gas(), 1, 0, 0x80, 0x20, 0x20))
            // If the ecrecover fails, the returndatasize will be 0x00,
            // `owner` will be be checked if it equals the hash at 0x00,
            // which evaluates to false (i.e. 0), and we will revert.
            // If the ecrecover succeeds, the returndatasize will be 0x20,
            // `owner` will be compared against the returned address at 0x20.
            if iszero(eq(mload(returndatasize()), owner)) {
                mstore(0x00, 0xddafbaef) // `InvalidPermit()`.
                revert(0x1c, 0x04)
            }
            // Compute the allowance slot and store the value.
            // The `owner` is already at slot 0x20.
            mstore(0x40, or(shl(160, _ALLOWANCE_SLOT_SEED), spender))
            sstore(keccak256(0x2c, 0x34), value)
            // Emit the {Approval} event.
            log3(add(m, 0x60), 0x20, _APPROVAL_EVENT_SIGNATURE, owner, spender)
            mstore(0x40, m) // Restore the free memory pointer.
            mstore(0x60, 0) // Restore the zero pointer.
        }
    }

    /// @dev Returns the EIP-2612 domains separator.
    function DOMAIN_SEPARATOR() public view virtual returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40) // Grab the free memory pointer.
        }
        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.
        bytes32 nameHash = keccak256(bytes(name()));
        /// @solidity memory-safe-assembly
        assembly {
            let m := result
            // `keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")`.
            // forgefmt: disable-next-item
            mstore(m, 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f)
            mstore(add(m, 0x20), nameHash)
            // `keccak256("1")`.
            // forgefmt: disable-next-item
            mstore(add(m, 0x40), 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6)
            mstore(add(m, 0x60), chainid())
            mstore(add(m, 0x80), address())
            result := keccak256(m, 0xa0)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  INTERNAL MINT FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Mints `amount` tokens to `to`, increasing the total supply.
    ///
    /// Emits a {Transfer} event.
    function _mint(address to, uint256 amount) internal virtual {
        _beforeTokenTransfer(address(0), to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            let totalSupplyBefore := sload(_TOTAL_SUPPLY_SLOT)
            let totalSupplyAfter := add(totalSupplyBefore, amount)
            // Revert if the total supply overflows.
            if lt(totalSupplyAfter, totalSupplyBefore) {
                mstore(0x00, 0xe5cfe957) // `TotalSupplyOverflow()`.
                revert(0x1c, 0x04)
            }
            // Store the updated total supply.
            sstore(_TOTAL_SUPPLY_SLOT, totalSupplyAfter)
            // Compute the balance slot and load its value.
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(address(0), to, amount);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  INTERNAL BURN FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Burns `amount` tokens from `from`, reducing the total supply.
    ///
    /// Emits a {Transfer} event.
    function _burn(address from, uint256 amount) internal virtual {
        _beforeTokenTransfer(from, address(0), amount);
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the balance slot and load its value.
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, from)
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Subtract and store the updated total supply.
            sstore(_TOTAL_SUPPLY_SLOT, sub(sload(_TOTAL_SUPPLY_SLOT), amount))
            // Emit the {Transfer} event.
            mstore(0x00, amount)
            log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)
        }
        _afterTokenTransfer(from, address(0), amount);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                INTERNAL TRANSFER FUNCTIONS                 */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Moves `amount` of tokens from `from` to `to`.
    function _transfer(address from, address to, uint256 amount) internal virtual {
        _beforeTokenTransfer(from, to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            let from_ := shl(96, from)
            // Compute the balance slot and load its value.
            mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Compute the balance slot of `to`.
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance of `to`.
            // Will not overflow because the sum of all user balances
            // cannot exceed the maximum uint256 value.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(from, to, amount);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                INTERNAL ALLOWANCE FUNCTIONS                */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Updates the allowance of `owner` for `spender` based on spent `amount`.
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the allowance slot and load its value.
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, owner)
            let allowanceSlot := keccak256(0x0c, 0x34)
            let allowance_ := sload(allowanceSlot)
            // If the allowance is not the maximum uint256 value.
            if iszero(eq(allowance_, not(0))) {
                // Revert if the amount to be transferred exceeds the allowance.
                if gt(amount, allowance_) {
                    mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.
                    revert(0x1c, 0x04)
                }
                // Subtract and store the updated allowance.
                sstore(allowanceSlot, sub(allowance_, amount))
            }
        }
    }

    /// @dev Sets `amount` as the allowance of `spender` over the tokens of `owner`.
    ///
    /// Emits a {Approval} event.
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            let owner_ := shl(96, owner)
            // Compute the allowance slot and store the amount.
            mstore(0x20, spender)
            mstore(0x0c, or(owner_, _ALLOWANCE_SLOT_SEED))
            sstore(keccak256(0x0c, 0x34), amount)
            // Emit the {Approval} event.
            mstore(0x00, amount)
            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, owner_), shr(96, mload(0x2c)))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     HOOKS TO OVERRIDE                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Hook that is called before any transfer of tokens.
    /// This includes minting and burning.
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /// @dev Hook that is called after any transfer of tokens.
    /// This includes minting and burning.
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// lib/solady/src/utils/SafeTransferLib.sol

/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
///
/// @dev Note:
/// - For ETH transfers, please use `forceSafeTransferETH` for gas griefing protection.
/// - For ERC20s, this implementation won't check that a token has code,
/// responsibility is delegated to the caller.
library SafeTransferLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ETH transfer has failed.
    error ETHTransferFailed();

    /// @dev The ERC20 `transferFrom` has failed.
    error TransferFromFailed();

    /// @dev The ERC20 `transfer` has failed.
    error TransferFailed();

    /// @dev The ERC20 `approve` has failed.
    error ApproveFailed();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Suggested gas stipend for contract receiving ETH
    /// that disallows any storage writes.
    uint256 internal constant _GAS_STIPEND_NO_STORAGE_WRITES = 2300;

    /// @dev Suggested gas stipend for contract receiving ETH to perform a few
    /// storage reads and writes, but low enough to prevent griefing.
    /// Multiply by a small constant (e.g. 2), if needed.
    uint256 internal constant _GAS_STIPEND_NO_GRIEF = 100000;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       ETH OPERATIONS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Sends `amount` (in wei) ETH to `to`.
    /// Reverts upon failure.
    ///
    /// Note: This implementation does NOT protect against gas griefing.
    /// Please use `forceSafeTransferETH` for gas griefing protection.
    function safeTransferETH(address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(gas(), to, amount, 0, 0, 0, 0)) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    /// The `gasStipend` can be set to a low enough value to prevent
    /// storage writes or gas griefing.
    ///
    /// If sending via the normal procedure fails, force sends the ETH by
    /// creating a temporary contract which uses `SELFDESTRUCT` to force send the ETH.
    ///
    /// Reverts if the current contract has insufficient balance.
    function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
        /// @solidity memory-safe-assembly
        assembly {
            // If insufficient balance, revert.
            if lt(selfbalance(), amount) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(gasStipend, to, amount, 0, 0, 0, 0)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                // We can directly use `SELFDESTRUCT` in the contract creation.
                // Compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758
                if iszero(create(amount, 0x0b, 0x16)) {
                    // To coerce gas estimation to provide enough gas for the `create` above.
                    if iszero(gt(gas(), 1000000)) { revert(0, 0) }
                }
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with a gas stipend
    /// equal to `_GAS_STIPEND_NO_GRIEF`. This gas stipend is a reasonable default
    /// for 99% of cases and can be overridden with the three-argument version of this
    /// function if necessary.
    ///
    /// If sending via the normal procedure fails, force sends the ETH by
    /// creating a temporary contract which uses `SELFDESTRUCT` to force send the ETH.
    ///
    /// Reverts if the current contract has insufficient balance.
    function forceSafeTransferETH(address to, uint256 amount) internal {
        // Manually inlined because the compiler doesn't inline functions with branches.
        /// @solidity memory-safe-assembly
        assembly {
            // If insufficient balance, revert.
            if lt(selfbalance(), amount) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(_GAS_STIPEND_NO_GRIEF, to, amount, 0, 0, 0, 0)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                // We can directly use `SELFDESTRUCT` in the contract creation.
                // Compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758
                if iszero(create(amount, 0x0b, 0x16)) {
                    // To coerce gas estimation to provide enough gas for the `create` above.
                    if iszero(gt(gas(), 1000000)) { revert(0, 0) }
                }
            }
        }
    }

    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    /// The `gasStipend` can be set to a low enough value to prevent
    /// storage writes or gas griefing.
    ///
    /// Simply use `gasleft()` for `gasStipend` if you don't need a gas stipend.
    ///
    /// Note: Does NOT revert upon failure.
    /// Returns whether the transfer of ETH is successful instead.
    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
        internal
        returns (bool success)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and check if it succeeded or not.
            success := call(gasStipend, to, amount, 0, 0, 0, 0)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      ERC20 OPERATIONS                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have at least `amount` approved for
    /// the current contract to manage.
    function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.

            mstore(0x60, amount) // Store the `amount` argument.
            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            // Store the function selector of `transferFrom(address,address,uint256)`.
            mstore(0x0c, 0x23b872dd000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends all of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have their entire balance approved for
    /// the current contract to manage.
    function safeTransferAllFrom(address token, address from, address to)
        internal
        returns (uint256 amount)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.

            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            // Store the function selector of `balanceOf(address)`.
            mstore(0x0c, 0x70a08231000000000000000000000000)
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // Store the function selector of `transferFrom(address,address,uint256)`.
            mstore(0x00, 0x23b872dd)
            // The `amount` argument is already written to the memory word at 0x60.
            amount := mload(0x60)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransfer(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            // Store the function selector of `transfer(address,uint256)`.
            mstore(0x00, 0xa9059cbb000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Sends all of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransferAll(address token, address to) internal returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.
            mstore(0x20, address()) // Store the address of the current contract.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x14, to) // Store the `to` argument.
            // The `amount` argument is already written to the memory word at 0x34.
            amount := mload(0x34)
            // Store the function selector of `transfer(address,uint256)`.
            mstore(0x00, 0xa9059cbb000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
    /// Reverts upon failure.
    function safeApprove(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            // Store the function selector of `approve(address,uint256)`.
            mstore(0x00, 0x095ea7b3000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `ApproveFailed()`.
                mstore(0x00, 0x3e3f8f73)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Returns the amount of ERC20 `token` owned by `account`.
    /// Returns zero if the `token` does not exist.
    function balanceOf(address token, address account) internal view returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, account) // Store the `account` argument.
            // Store the function selector of `balanceOf(address)`.
            mstore(0x00, 0x70a08231000000000000000000000000)
            amount :=
                mul(
                    mload(0x20),
                    and( // The arguments of `and` are evaluated from right to left.
                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
                    )
                )
        }
    }
}

// src/base/interfaces/ILiquidityGauge.sol

interface ILiquidityGauge {
    struct Reward {
        address token;
        address distributor;
        // solhint-disable-next-line
        uint256 period_finish;
        uint256 rate;
        // solhint-disable-next-line
        uint256 last_update;
        uint256 integral;
    }

    // solhint-disable-next-line
    function deposit_reward_token(address _rewardToken, uint256 _amount) external;

    // solhint-disable-next-line
    function claim_rewards_for(address _user, address _recipient) external;

    // solhint-disable-next-line
    function working_balances(address _address) external view returns (uint256);

    // solhint-disable-next-line
    function deposit(uint256 _value, address _addr) external;

    // solhint-disable-next-line
    function reward_tokens(uint256 _i) external view returns (address);

    // solhint-disable-next-line
    function reward_data(address _tokenReward) external view returns (Reward memory);

    function balanceOf(address) external returns (uint256);

    // solhint-disable-next-line
    function claimable_reward(address _user, address _reward_token) external view returns (uint256);

    // solhint-disable-next-line
    function claimable_tokens(address _user) external returns (uint256);

    // solhint-disable-next-line
    function user_checkpoint(address _user) external returns (bool);

    // solhint-disable-next-line
    function commit_transfer_ownership(address) external;

    // solhint-disable-next-line
    function claim_rewards() external;

    // solhint-disable-next-line
    function claim_rewards(address) external;

    // solhint-disable-next-line
    function claim_rewards(address, address) external;

    // solhint-disable-next-line
    function add_reward(address, address) external;

    // solhint-disable-next-line
    function set_claimer(address) external;

    function admin() external view returns (address);

    function future_admin() external view returns (address);

    // solhint-disable-next-line
    function set_reward_distributor(address _rewardToken, address _newDistrib) external;

    function initialize(
        // solhint-disable-next-line
        address staking_token,
        address admin,
        address sdt,
        // solhint-disable-next-line
        address voting_escrow,
        // solhint-disable-next-line
        address veBoost_proxy,
        address distributor
    ) external;

    function totalSupply() external returns (uint256);

    function withdraw(uint256 _value, bool _claimReward) external;

    function withdraw(uint256 _valut, address _user, bool _claimReward) external;

    // solhint-disable-next-line
    function accept_transfer_ownership() external;

    // solhint-disable-next-line
    function claimed_reward(address _addr, address _token) external view returns (uint256);

    // solhint-disable-next-line
    function set_rewards_receiver(address _receiver) external;
}

// src/base/interfaces/ILocker.sol

interface ILocker {
    function createLock(uint256, uint256) external;

    function claimAllRewards(address[] calldata _tokens, address _recipient) external;

    function increaseAmount(uint256) external;

    function increaseAmount(uint128) external;

    function increaseUnlockTime(uint256) external;

    function release() external;

    function claimRewards(address, address) external;

    function claimRewards(address, address, address) external;

    function claimFXSRewards(address) external;

    function claimFPISRewards(address) external;

    function execute(address, uint256, bytes calldata) external returns (bool, bytes memory);

    function setGovernance(address) external;

    function voteGaugeWeight(address, uint256) external;

    function setAngleDepositor(address) external;

    function setDepositor(address) external;

    function setFxsDepositor(address) external;

    function setYFIDepositor(address) external;

    function setYieldDistributor(address) external;

    function setGaugeController(address) external;

    function setAccumulator(address _accumulator) external;

    function governance() external view returns (address);

    function increaseLock(uint256 _value, uint256 _duration) external;

    function release(address _recipient) external;

    function transferGovernance(address _governance) external;

    function acceptGovernance() external;

    function setStrategy(address _strategy) external;

    function claimRewards(address _recipient, address[] calldata _pools) external;
}

// src/base/interfaces/ISDTDistributor.sol

interface ISDTDistributor {
    function distribute(address gaugeAddr) external;
}

// src/base/interfaces/IYieldDistributor.sol

interface IYieldDistributor {
    function getYield() external returns (uint256);

    function getYieldThirdParty(address _staker) external;

    function checkpoint() external;

    function userVeFXSCheckpointed(address _user) external view returns (uint256);
}

// src/base/accumulator/AccumulatorV2.sol

/// @title Accumulator V2
/// @notice Abstract contract used for any accumulator
/// @dev Interacting with the FeeReceiver (receiving and splitting fees)
/// @author StakeDAO
abstract contract AccumulatorV2 {
    /// @notice Denominator for fixed point math.
    uint256 public constant DENOMINATOR = 10_000;

    /// @notice Split struct
    /// @param receivers Array of receivers
    /// @param fees Array of fees
    /// @dev First go to the first receiver, then the second, and so on
    /// @dev Fee in basis points, where 10,000 basis points = 100%
    struct Split {
        address[] receivers;
        uint256[] fees; // Fee in basis points, where 10,000 basis points = 100%
    }

    /// @notice Fee split.
    Split feeSplit;

    /// @notice SDT distributor
    address public sdtDistributor;

    /// @notice Claimer Fee.
    uint256 public claimerFee;

    /// @notice sd gauge
    address public immutable gauge;

    /// @notice sd locker
    address public immutable locker;

    /// @notice governance
    address public governance;

    /// @notice future governance
    address public futureGovernance;

    /// @notice Fee receiver contracts defined in Strategy
    address public feeReceiver;

    ////////////////////////////////////////////////////////////////
    /// --- EVENTS & ERRORS
    ///////////////////////////////////////////////////////////////

    /// @notice Event emitted when the claimer fee is set
    event ClaimerFeeSet(uint256 claimerFee);

    /// @notice Emitted when the fee receiver is set
    event FeeReceiverSet(address _feeReceiver);

    /// @notice Event emitted when an ERC20 token is rescued
    event ERC20Rescued(address token, uint256 amount);

    /// @notice Event emitted when a new future governance has set
    event TransferGovernance(address futureGovernance);

    /// @notice Event emitted when the future governance accepts to be the governance
    event GovernanceChanged(address governance);

    /// @notice Error emitted when an onlyGovernance function has called by a different address
    error GOVERNANCE();

    /// @notice Error emitted when the total fee would be more than 100%
    error FEE_TOO_HIGH();

    /// @notice Error emitted when an onlyFutureGovernance function has called by a different address
    error FUTURE_GOVERNANCE();

    /// @notice Error emitted when a zero address is pass
    error ZERO_ADDRESS();

    /// @notice Error emitted when the fee is invalid
    error INVALID_SPLIT();

    //////////////////////////////////////////////////////
    /// --- MODIFIERS
    //////////////////////////////////////////////////////

    /// @notice Modifier to check if the caller is the governance
    modifier onlyGovernance() {
        if (msg.sender != governance) revert GOVERNANCE();
        _;
    }

    /// @notice Modifier to check if the caller is the future governance
    modifier onlyFutureGovernance() {
        if (msg.sender != futureGovernance) revert FUTURE_GOVERNANCE();
        _;
    }

    //////////////////////////////////////////////////////
    /// --- CONSTRUCTOR
    //////////////////////////////////////////////////////

    /// @notice Constructor
    /// @param _gauge sd gauge
    /// @param _locker sd locker
    /// @param _governance governance
    constructor(address _gauge, address _locker, address _governance) {
        gauge = _gauge;
        locker = _locker;

        governance = _governance;

        claimerFee = 10; // 0.1%
    }

    //////////////////////////////////////////////////////
    /// --- MUTATIVE FUNCTIONS
    //////////////////////////////////////////////////////

    /// @notice Claims all rewards tokens for the locker and notify them to the LGV4
    function claimAndNotifyAll(bool notifySDT, bool pullFromFeeReceiver, bool claimFeeStrategy) external virtual {}

    /// @notice Claims a reward token for the locker and notify them to the LGV4
    function claimTokenAndNotifyAll(address token, bool notifySDT, bool pullFromFeeReceiver, bool claimFeeStrategy)
        external
        virtual
    {}

    /// @notice Notify the whole acc balance of a token
    /// @param _token token to notify
    /// @param _notifySDT if notify SDT or not
    /// @param _pullFromFeeReceiver if pull tokens from the fee receiver or not
    function notifyReward(address _token, bool _notifySDT, bool _pullFromFeeReceiver) public virtual {
        uint256 amount = ERC20(_token).balanceOf(address(this));
        // notify token as reward in sdToken gauge
        _notifyReward(_token, amount, _pullFromFeeReceiver);

        if (_notifySDT) {
            // notify SDT
            _distributeSDT();
        }
    }

    //////////////////////////////////////////////////////
    /// --- INTERNAL FUNCTIONS
    //////////////////////////////////////////////////////

    /// @notice Notify the new reward to the LGV4
    /// @param _tokenReward token to notify
    /// @param _amount amount to notify
    /// @param _pullFromFeeReceiver if pull tokens from the fee receiver or not (tokens already in that contract)
    function _notifyReward(address _tokenReward, uint256 _amount, bool _pullFromFeeReceiver) internal virtual {
        _chargeFee(_tokenReward, _amount);

        if (_pullFromFeeReceiver && feeReceiver != address(0)) {
            // Split fees for the specified token using the fee receiver contract
            // Function not permissionless, to prevent sending to that accumulator and re-splitting (_chargeFee)
            IFeeReceiver(feeReceiver).split(_tokenReward);
        }

        _amount = ERC20(_tokenReward).balanceOf(address(this));

        if (_amount == 0) return;
        ILiquidityGauge(gauge).deposit_reward_token(_tokenReward, _amount);
    }

    /// @notice Distribute SDT to the gauge
    function _distributeSDT() internal {
        if (sdtDistributor != address(0)) {
            ISDTDistributor(sdtDistributor).distribute(gauge);
        }
    }

    /// @notice Charge fee for dao, liquidity, claimer
    /// @param _token token to charge fee for
    /// @param _amount amount to charge fee for
    function _chargeFee(address _token, uint256 _amount) internal returns (uint256 _charged) {
        if (_amount == 0) return 0;

        Split memory _feeSplit = getFeeSplit();
        uint256 fee;
        for (uint256 i = 0; i < _feeSplit.receivers.length; i++) {
            fee = (_amount * _feeSplit.fees[i]) / DENOMINATOR;
            SafeTransferLib.safeTransfer(_token, _feeSplit.receivers[i], fee);

            _charged += fee;
        }

        /// Claimer fee.
        fee = (_amount * claimerFee) / DENOMINATOR;
        SafeTransferLib.safeTransfer(_token, msg.sender, fee);

        _charged += fee;
    }

    /// @notice Take the fees accumulated from the strategy and sending to the fee receiver
    /// @dev Need to be done before calling `split`, but claimProtocolFees is permissionless.
    /// @dev Strategy not set in that abstract contract, must be implemented by child contracts
    function _claimFeeStrategy(address _strategy) internal {
        // Call the claimProtocolFees function from the strategy
        (bool success, bytes memory returnData) = _strategy.call(abi.encodeWithSignature("claimProtocolFees()"));

        if (!success) {
            if (returnData.length == 0) revert("Strategy call failed");
            assembly {
                revert(add(returnData, 32), returnData) // Reverts with an error message from the returnData
            }
        }
    }

    //////////////////////////////////////////////////////
    /// --- GOVERNANCE FUNCTIONS
    //////////////////////////////////////////////////////

    function getFeeSplit() public view returns (Split memory) {
        return feeSplit;
    }

    function setClaimerFee(uint256 _claimerFee) external onlyGovernance {
        if (_claimerFee > DENOMINATOR) revert FEE_TOO_HIGH();
        emit ClaimerFeeSet(claimerFee = _claimerFee);
    }

    /// @notice Set SDT distributor.
    /// @param _distributor SDT distributor address.
    function setDistributor(address _distributor) external onlyGovernance {
        sdtDistributor = _distributor;
    }

    /// @notice Set fee receiver (from Stategy)
    /// @param _feeReceiver Fee receiver address
    function setFeeReceiver(address _feeReceiver) external onlyGovernance {
        emit FeeReceiverSet(feeReceiver = _feeReceiver);
    }

    /// @notice Set a new future governance that can accept it
    /// @dev Can be called only by the governance
    /// @param _futureGovernance future governance address
    function transferGovernance(address _futureGovernance) external onlyGovernance {
        if (_futureGovernance == address(0)) revert ZERO_ADDRESS();
        futureGovernance = _futureGovernance;
        emit TransferGovernance(_futureGovernance);
    }

    /// @notice Accept the governance
    /// @dev Can be called only by future governance
    function acceptGovernance() external onlyFutureGovernance {
        governance = futureGovernance;
        emit GovernanceChanged(governance);
    }

    /// @notice Approve the distribution of a new token reward from the Accumulator.
    /// @param _newTokenReward New token reward to be approved.
    function approveNewTokenReward(address _newTokenReward) external onlyGovernance {
        SafeTransferLib.safeApprove(_newTokenReward, gauge, type(uint256).max);
    }

    /// @notice Set fee split
    /// @param receivers array of receivers
    /// @param fees array of fees
    function setFeeSplit(address[] calldata receivers, uint256[] calldata fees) external onlyGovernance {
        if (receivers.length == 0 || receivers.length != fees.length) revert INVALID_SPLIT();
        feeSplit = Split(receivers, fees);
    }

    /// @notice A function that rescue any ERC20 token
    /// @dev Can be called only by the governance
    /// @param _token token address
    /// @param _amount amount to rescue
    /// @param _recipient address to send token rescued
    function rescueERC20(address _token, uint256 _amount, address _recipient) external onlyGovernance {
        if (_recipient == address(0)) revert ZERO_ADDRESS();
        SafeTransferLib.safeTransfer(_token, _recipient, _amount);
        emit ERC20Rescued(_token, _amount);
    }

    receive() external payable {}
}

// src/frax/fxs/accumulator/FxsAccumulatorFraxtal.sol

/// @title A contract that accumulates FXS rewards and notifies them to the LGV4
/// @author StakeDAO
contract FxsAccumulatorFraxtal is AccumulatorV2 {
    /// @notice FXS token address
    address public constant FXS = 0xFc00000000000000000000000000000000000002;

    /// @notice FXS ethereum locker
    address public constant ETH_LOCKER = 0xCd3a267DE09196C48bbB1d9e842D7D7645cE448f;

    /// @notice FXS yield distributor
    address public yieldDistributor = 0x21359d1697e610e25C8229B2C57907378eD09A2E;

    /// @notice Strategy address
    address public strategy;

    /// @notice Throwed when a low level call fails
    error CallFailed();

    //////////////////////////////////////////////////////
    /// --- CONSTRUCTOR
    //////////////////////////////////////////////////////

    /// @notice Constructor
    /// @param _gauge sd gauge
    /// @param _locker sd locker
    /// @param _governance governance
    /// @param _delegationRegistry delegation registry
    /// @param _initialDelegate initial delegate
    constructor(
        address _gauge,
        address _locker,
        address _governance,
        address _delegationRegistry,
        address _initialDelegate
    ) AccumulatorV2(_gauge, _locker, _governance) {
        SafeTransferLib.safeApprove(FXS, _gauge, type(uint256).max);

        // Custom code for Fraxtal
        // set _initialDelegate as delegate
        (bool success,) =
            _delegationRegistry.call(abi.encodeWithSignature("setDelegationForSelf(address)", _initialDelegate));
        if (!success) revert CallFailed();
        // disable self managing delegation
        (success,) = _delegationRegistry.call(abi.encodeWithSignature("disableSelfManagingDelegations()"));
        if (!success) revert CallFailed();
    }

    //////////////////////////////////////////////////////
    /// --- MUTATIVE FUNCTIONS
    //////////////////////////////////////////////////////

    /// @notice Claim FXS rewards for the locker and notify all to the LGV4
    /// @param _notifySDT if notify SDT or not
    /// @param _pullFromFeeSplitter if pull tokens from the fee splitter or not
    /// @param _claimStrategyFee if claim or not strategy fees
    /// @notice Claims all rewards tokens for the locker and notify them to the LGV4
    function claimAndNotifyAll(bool _notifySDT, bool _pullFromFeeSplitter, bool _claimStrategyFee) external override {
        // Sending strategy fees to fee receiver
        if (_claimStrategyFee && strategy != address(0)) {
            _claimFeeStrategy(strategy);
        }

        /// Claim FXS reward for L1's veFXS bridged, on behalf of the eth locker
        IYieldDistributor(yieldDistributor).getYieldThirdParty(ETH_LOCKER);

        /// Claim FXS reward for fraxtal's veFXS
        ILocker(locker).claimRewards(yieldDistributor, FXS, address(this));

        /// Notify FXS to the gauge.
        notifyReward(FXS, _notifySDT, _pullFromFeeSplitter);
    }

    /// @notice Set frax yield distributor
    /// @param _yieldDistributor Address of the frax yield distributor
    function setYieldDistributor(address _yieldDistributor) external onlyGovernance {
        yieldDistributor = _yieldDistributor;
    }

    /// @notice Set strategy
    /// @param _strategy Address of the strategy
    function setStrategy(address _strategy) external onlyGovernance {
        strategy = _strategy;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_gauge","type":"address"},{"internalType":"address","name":"_locker","type":"address"},{"internalType":"address","name":"_governance","type":"address"},{"internalType":"address","name":"_delegationRegistry","type":"address"},{"internalType":"address","name":"_initialDelegate","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CallFailed","type":"error"},{"inputs":[],"name":"FEE_TOO_HIGH","type":"error"},{"inputs":[],"name":"FUTURE_GOVERNANCE","type":"error"},{"inputs":[],"name":"GOVERNANCE","type":"error"},{"inputs":[],"name":"INVALID_SPLIT","type":"error"},{"inputs":[],"name":"ZERO_ADDRESS","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"claimerFee","type":"uint256"}],"name":"ClaimerFeeSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20Rescued","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_feeReceiver","type":"address"}],"name":"FeeReceiverSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"governance","type":"address"}],"name":"GovernanceChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"futureGovernance","type":"address"}],"name":"TransferGovernance","type":"event"},{"inputs":[],"name":"DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ETH_LOCKER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FXS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newTokenReward","type":"address"}],"name":"approveNewTokenReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_notifySDT","type":"bool"},{"internalType":"bool","name":"_pullFromFeeSplitter","type":"bool"},{"internalType":"bool","name":"_claimStrategyFee","type":"bool"}],"name":"claimAndNotifyAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"bool","name":"notifySDT","type":"bool"},{"internalType":"bool","name":"pullFromFeeReceiver","type":"bool"},{"internalType":"bool","name":"claimFeeStrategy","type":"bool"}],"name":"claimTokenAndNotifyAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimerFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"futureGovernance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gauge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFeeSplit","outputs":[{"components":[{"internalType":"address[]","name":"receivers","type":"address[]"},{"internalType":"uint256[]","name":"fees","type":"uint256[]"}],"internalType":"struct AccumulatorV2.Split","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"locker","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"bool","name":"_notifySDT","type":"bool"},{"internalType":"bool","name":"_pullFromFeeReceiver","type":"bool"}],"name":"notifyReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_recipient","type":"address"}],"name":"rescueERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sdtDistributor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_claimerFee","type":"uint256"}],"name":"setClaimerFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_distributor","type":"address"}],"name":"setDistributor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeReceiver","type":"address"}],"name":"setFeeReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"receivers","type":"address[]"},{"internalType":"uint256[]","name":"fees","type":"uint256[]"}],"name":"setFeeSplit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_strategy","type":"address"}],"name":"setStrategy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_yieldDistributor","type":"address"}],"name":"setYieldDistributor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"strategy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_futureGovernance","type":"address"}],"name":"transferGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"yieldDistributor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0x6080604052600436106101855760003560e01c8063a6f19c84116100d1578063d38bfff41161008a578063e20c079911610064578063e20c079914610495578063eda0be69146104b5578063efdcd974146104d7578063fc0f372e146104f757600080fd5b8063d38bfff414610421578063d7b96d4e14610441578063e02dd6ec1461047557600080fd5b8063a6f19c8414610344578063a8c62e7614610378578063ac24ef2514610398578063b3f00674146103b8578063ba32fe53146103d8578063c5b60e341461040057600080fd5b806367871a9c1161013e57806377662ffc1161011857806377662ffc146102c05780638070c503146102e0578063918f867414610300578063a38c2c3d1461032457600080fd5b806367871a9c1461026057806368752f5e1461028057806375619ab5146102a057600080fd5b806315f5c30014610191578063200ea222146101ce578063238efcbc146101e95780633038a60d1461020057806333a100ca146102205780635aa6e6751461024057600080fd5b3661018c57005b600080fd5b34801561019d57600080fd5b506002546101b1906001600160a01b031681565b6040516001600160a01b0390911681526020015b60405180910390f35b3480156101da57600080fd5b506101b16002603f609a1b0181565b3480156101f557600080fd5b506101fe61050d565b005b34801561020c57600080fd5b506101fe61021b3660046111ed565b61058e565b34801561022c57600080fd5b506101fe61023b3660046111ed565b6105db565b34801561024c57600080fd5b506004546101b1906001600160a01b031681565b34801561026c57600080fd5b506101fe61027b36600461121f565b610628565b34801561028c57600080fd5b506101fe61029b3660046112ae565b6106ae565b3480156102ac57600080fd5b506101fe6102bb3660046111ed565b6107b4565b3480156102cc57600080fd5b506101fe6102db36600461131a565b610801565b3480156102ec57600080fd5b506005546101b1906001600160a01b031681565b34801561030c57600080fd5b5061031661271081565b6040519081526020016101c5565b34801561033057600080fd5b506007546101b1906001600160a01b031681565b34801561035057600080fd5b506101b17f00000000000000000000000012992595328e52267c95e45b1a97014d6ddf868381565b34801561038457600080fd5b506008546101b1906001600160a01b031681565b3480156103a457600080fd5b506101fe6103b33660046111ed565b6108a5565b3480156103c457600080fd5b506006546101b1906001600160a01b031681565b3480156103e457600080fd5b506101b173cd3a267de09196c48bbb1d9e842d7d7645ce448f81565b34801561040c57600080fd5b506101fe61041b36600461134d565b50505050565b34801561042d57600080fd5b506101fe61043c3660046111ed565b610900565b34801561044d57600080fd5b506101b17f00000000000000000000000026acff2adc9104fe1c26c958dc4c9a5180840c3581565b34801561048157600080fd5b506101fe6104903660046113a1565b6109a7565b3480156104a157600080fd5b506101fe6104b03660046113ba565b610a2a565b3480156104c157600080fd5b506104ca610b76565b6040516101c591906113d8565b3480156104e357600080fd5b506101fe6104f23660046111ed565b610c4d565b34801561050357600080fd5b5061031660035481565b6005546001600160a01b0316331461053857604051637ea33de360e01b815260040160405180910390fd5b600554600480546001600160a01b0319166001600160a01b0390921691821790556040519081527fa6a85f15b976d399f39ad43e515e75910bac714bc55eeff6131fb90780d6f7469060200160405180910390a1565b6004546001600160a01b031633146105b9576040516305189e0d60e21b815260040160405180910390fd5b600780546001600160a01b0319166001600160a01b0392909216919091179055565b6004546001600160a01b03163314610606576040516305189e0d60e21b815260040160405180910390fd5b600880546001600160a01b0319166001600160a01b0392909216919091179055565b6040516370a0823160e01b81523060048201526000906001600160a01b038516906370a0823190602401602060405180830381865afa15801561066f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106939190611476565b90506106a0848284610cc6565b821561041b5761041b610e42565b6004546001600160a01b031633146106d9576040516305189e0d60e21b815260040160405180910390fd5b8215806106e65750828114155b156107045760405163e22b17a960e01b815260040160405180910390fd5b604051806040016040528085858080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525050509082525060408051602085810282810182019093528582529283019290918691869182918501908490808284376000920182905250939094525050825180519192506107929183916020019061111c565b5060208281015180516107ab9260018501920190611181565b50505050505050565b6004546001600160a01b031633146107df576040516305189e0d60e21b815260040160405180910390fd5b600280546001600160a01b0319166001600160a01b0392909216919091179055565b6004546001600160a01b0316331461082c576040516305189e0d60e21b815260040160405180910390fd5b6001600160a01b0381166108535760405163538ba4f960e01b815260040160405180910390fd5b61085e838284610ed0565b604080516001600160a01b0385168152602081018490527f517b987a19eede59a32f4e7dd466dee9bdf6446b24a501bdab5b60c5ef6747bf910160405180910390a1505050565b6004546001600160a01b031633146108d0576040516305189e0d60e21b815260040160405180910390fd5b6108fd817f00000000000000000000000012992595328e52267c95e45b1a97014d6ddf8683600019610f16565b50565b6004546001600160a01b0316331461092b576040516305189e0d60e21b815260040160405180910390fd5b6001600160a01b0381166109525760405163538ba4f960e01b815260040160405180910390fd5b600580546001600160a01b0319166001600160a01b0383169081179091556040519081527fde4aabcd09171142d82dd9e667db43bf0dca12f30fa0aec30859875d35ecb5d6906020015b60405180910390a150565b6004546001600160a01b031633146109d2576040516305189e0d60e21b815260040160405180910390fd5b6127108111156109f5576040516345fbd9c160e01b815260040160405180910390fd5b60038190556040518181527f38bb796c5d377fb179e02dc17bc62ca5af5146b5334a9f39828d5efaab5977819060200161099c565b808015610a4157506008546001600160a01b031615155b15610a5b57600854610a5b906001600160a01b0316610f52565b60075460405163f3b0fb4560e01b815273cd3a267de09196c48bbb1d9e842d7d7645ce448f60048201526001600160a01b039091169063f3b0fb4590602401600060405180830381600087803b158015610ab457600080fd5b505af1158015610ac8573d6000803e3d6000fd5b50506007546040516376e1a76760e11b81526001600160a01b0391821660048201526002603f609a1b0160248201523060448201527f00000000000000000000000026acff2adc9104fe1c26c958dc4c9a5180840c35909116925063edc34ece9150606401600060405180830381600087803b158015610b4757600080fd5b505af1158015610b5b573d6000803e3d6000fd5b50505050610b716002603f609a1b018484610628565b505050565b6040805180820190915260608082526020820152604080516000805460606020820284018101855293830181815292939192849290918491840182828015610be757602002820191906000526020600020905b81546001600160a01b03168152600190910190602001808311610bc9575b5050505050815260200160018201805480602002602001604051908101604052809291908181526020018280548015610c3f57602002820191906000526020600020905b815481526020019060010190808311610c2b575b505050505081525050905090565b6004546001600160a01b03163314610c78576040516305189e0d60e21b815260040160405180910390fd5b600680546001600160a01b0319166001600160a01b0383169081179091556040519081527fbdf37c276f641820b141429d245add2552b4118c0866e5a78638e3de5ef18d9d9060200161099c565b610cd08383611034565b50808015610ce857506006546001600160a01b031615155b15610d4d5760065460405163056fa47f60e41b81526001600160a01b038581166004830152909116906356fa47f090602401600060405180830381600087803b158015610d3457600080fd5b505af1158015610d48573d6000803e3d6000fd5b505050505b6040516370a0823160e01b81523060048201526001600160a01b038416906370a0823190602401602060405180830381865afa158015610d91573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610db59190611476565b915081600003610dc457505050565b6040516393f7aa6760e01b81526001600160a01b038481166004830152602482018490527f00000000000000000000000012992595328e52267c95e45b1a97014d6ddf868316906393f7aa6790604401600060405180830381600087803b158015610e2e57600080fd5b505af11580156107ab573d6000803e3d6000fd5b6002546001600160a01b031615610ece576002546040516363453ae160e01b81526001600160a01b037f00000000000000000000000012992595328e52267c95e45b1a97014d6ddf868381166004830152909116906363453ae190602401600060405180830381600087803b158015610eba57600080fd5b505af115801561041b573d6000803e3d6000fd5b565b816014528060345263a9059cbb60601b60005260206000604460106000875af13d156001600051141716610f0c576390b8ec186000526004601cfd5b6000603452505050565b816014528060345263095ea7b360601b60005260206000604460106000875af13d156001600051141716610f0c57633e3f8f736000526004601cfd5b60408051600481526024810182526020810180516001600160e01b0316634a7d036960e01b179052905160009182916001600160a01b03851691610f959161148f565b6000604051808303816000865af19150503d8060008114610fd2576040519150601f19603f3d011682016040523d82523d6000602084013e610fd7565b606091505b509150915081610b7157805160000361102d5760405162461bcd60e51b815260206004820152601460248201527314dd1c985d1959de4818d85b1b0819985a5b195960621b604482015260640160405180910390fd5b8060208201fd5b60008160000361104657506000611116565b6000611050610b76565b90506000805b8251518110156110de5761271083602001518281518110611079576110796114be565b60200260200101518661108c91906114ea565b6110969190611501565b91506110c086846000015183815181106110b2576110b26114be565b602002602001015184610ed0565b6110ca8285611523565b9350806110d681611536565b915050611056565b50612710600354856110f091906114ea565b6110fa9190611501565b9050611107853383610ed0565b6111118184611523565b925050505b92915050565b828054828255906000526020600020908101928215611171579160200282015b8281111561117157825182546001600160a01b0319166001600160a01b0390911617825560209092019160019091019061113c565b5061117d9291506111bc565b5090565b828054828255906000526020600020908101928215611171579160200282015b828111156111715782518255916020019190600101906111a1565b5b8082111561117d57600081556001016111bd565b80356001600160a01b03811681146111e857600080fd5b919050565b6000602082840312156111ff57600080fd5b611208826111d1565b9392505050565b803580151581146111e857600080fd5b60008060006060848603121561123457600080fd5b61123d846111d1565b925061124b6020850161120f565b91506112596040850161120f565b90509250925092565b60008083601f84011261127457600080fd5b50813567ffffffffffffffff81111561128c57600080fd5b6020830191508360208260051b85010111156112a757600080fd5b9250929050565b600080600080604085870312156112c457600080fd5b843567ffffffffffffffff808211156112dc57600080fd5b6112e888838901611262565b9096509450602087013591508082111561130157600080fd5b5061130e87828801611262565b95989497509550505050565b60008060006060848603121561132f57600080fd5b611338846111d1565b925060208401359150611259604085016111d1565b6000806000806080858703121561136357600080fd5b61136c856111d1565b935061137a6020860161120f565b92506113886040860161120f565b91506113966060860161120f565b905092959194509250565b6000602082840312156113b357600080fd5b5035919050565b6000806000606084860312156113cf57600080fd5b61123d8461120f565b6020808252825160408383015280516060840181905260009291820190839060808601905b808310156114265783516001600160a01b031682529284019260019290920191908401906113fd565b5086840151868203601f190160408801528051808352908501935090840191506000905b8082101561146a578351835292840192918401916001919091019061144a565b50909695505050505050565b60006020828403121561148857600080fd5b5051919050565b6000825160005b818110156114b05760208186018101518583015201611496565b506000920191825250919050565b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b8082028115828204841417611116576111166114d4565b60008261151e57634e487b7160e01b600052601260045260246000fd5b500490565b80820180821115611116576111166114d4565b600060018201611548576115486114d4565b506001019056fea2646970667358221220e21ee403ff5d5de9cf29e32b3ad4f70b71e030b323fb432312eff6555b17855264736f6c63430008130033

00000000000000000000000012992595328e52267c95e45b1a97014d6ddf868300000000000000000000000026acff2adc9104fe1c26c958dc4c9a5180840c35000000000000000000000000000755fbe4a24d7478bfcfc1e561afce82d1ff62000000000000000000000000098c837fef2e146e96ceaf58a10f68fc6326dc4c000000000000000000000000b0552b6860ce5c0202976db056b5e3cc4f9cc765

-----Decoded View---------------
Arg [0] : _gauge (address): 0x12992595328E52267c95e45B1a97014D6Ddf8683
Arg [1] : _locker (address): 0x26aCff2adc9104FE1c26c958dC4C9a5180840c35
Arg [2] : _governance (address): 0x000755Fbe4A24d7478bfcFC1E561AfCE82d1ff62
Arg [3] : _delegationRegistry (address): 0x098c837FeF2e146e96ceAF58A10F68Fc6326DC4C
Arg [4] : _initialDelegate (address): 0xB0552b6860CE5C0202976Db056b5e3Cc4f9CC765

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 00000000000000000000000012992595328e52267c95e45b1a97014d6ddf8683
Arg [1] : 00000000000000000000000026acff2adc9104fe1c26c958dc4c9a5180840c35
Arg [2] : 000000000000000000000000000755fbe4a24d7478bfcfc1e561afce82d1ff62
Arg [3] : 000000000000000000000000098c837fef2e146e96ceaf58a10f68fc6326dc4c
Arg [4] : 000000000000000000000000b0552b6860ce5c0202976db056b5e3cc4f9cc765

60339:3362:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50399:29;;;;;;;;;;-1:-1:-1;50399:29:0;;;;-1:-1:-1;;;;;50399:29:0;;;;;;-1:-1:-1;;;;;178:32:1;;;160:51;;148:2;133:18;50399:29:0;;;;;;;;60429:72;;;;;;;;;;;;-1:-1:-1;;;;;60429:72:0;;58758:151;;;;;;;;;;;;;:::i;:::-;;63372:135;;;;;;;;;;-1:-1:-1;63372:135:0;;;;;:::i;:::-;;:::i;63595:103::-;;;;;;;;;;-1:-1:-1;63595:103:0;;;;;:::i;:::-;;:::i;50661:25::-;;;;;;;;;;-1:-1:-1;50661:25:0;;;;-1:-1:-1;;;;;50661:25:0;;;54019:383;;;;;;;;;;-1:-1:-1;54019:383:0;;;;;:::i;:::-;;:::i;59356:247::-;;;;;;;;;;-1:-1:-1;59356:247:0;;;;;:::i;:::-;;:::i;57857:118::-;;;;;;;;;;-1:-1:-1;57857:118:0;;;;;:::i;:::-;;:::i;59853:281::-;;;;;;;;;;-1:-1:-1;59853:281:0;;;;;:::i;:::-;;:::i;50730:31::-;;;;;;;;;;-1:-1:-1;50730:31:0;;;;-1:-1:-1;;;;;50730:31:0;;;49870:44;;;;;;;;;;;;49908:6;49870:44;;;;;2712:25:1;;;2700:2;2685:18;49870:44:0;2566:177:1;60674:76:0;;;;;;;;;;-1:-1:-1;60674:76:0;;;;-1:-1:-1;;;;;60674:76:0;;;50527:30;;;;;;;;;;;;;;;60793:23;;;;;;;;;;-1:-1:-1;60793:23:0;;;;-1:-1:-1;;;;;60793:23:0;;;59068:169;;;;;;;;;;-1:-1:-1;59068:169:0;;;;;:::i;:::-;;:::i;50830:26::-;;;;;;;;;;-1:-1:-1;50830:26:0;;;;-1:-1:-1;;;;;50830:26:0;;;60547:79;;;;;;;;;;;;60584:42;60547:79;;53632:154;;;;;;;;;;-1:-1:-1;53632:154:0;;;;;:::i;:::-;54116:286;54019:383;;;;58401:256;;;;;;;;;;-1:-1:-1;58401:256:0;;;;;:::i;:::-;;:::i;50593:31::-;;;;;;;;;;;;;;;57563:194;;;;;;;;;;-1:-1:-1;57563:194:0;;;;;:::i;:::-;;:::i;62572:676::-;;;;;;;;;;-1:-1:-1;62572:676:0;;;;;:::i;:::-;;:::i;57463:92::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;58082:136::-;;;;;;;;;;-1:-1:-1;58082:136:0;;;;;:::i;:::-;;:::i;50467:25::-;;;;;;;;;;;;;;;;58758:151;52631:16;;-1:-1:-1;;;;;52631:16:0;52617:10;:30;52613:62;;52656:19;;-1:-1:-1;;;52656:19:0;;;;;;;;;;;52613:62;58840:16:::1;::::0;58827:10:::1;:29:::0;;-1:-1:-1;;;;;;58827:29:0::1;-1:-1:-1::0;;;;;58840:16:0;;::::1;58827:29:::0;;::::1;::::0;;58872::::1;::::0;160:51:1;;;58872:29:0::1;::::0;148:2:1;133:18;58872:29:0::1;;;;;;;58758:151::o:0;63372:135::-;52437:10;;-1:-1:-1;;;;;52437:10:0;52423;:24;52419:49;;52456:12;;-1:-1:-1;;;52456:12:0;;;;;;;;;;;52419:49;63463:16:::1;:36:::0;;-1:-1:-1;;;;;;63463:36:0::1;-1:-1:-1::0;;;;;63463:36:0;;;::::1;::::0;;;::::1;::::0;;63372:135::o;63595:103::-;52437:10;;-1:-1:-1;;;;;52437:10:0;52423;:24;52419:49;;52456:12;;-1:-1:-1;;;52456:12:0;;;;;;;;;;;52419:49;63670:8:::1;:20:::0;;-1:-1:-1;;;;;;63670:20:0::1;-1:-1:-1::0;;;;;63670:20:0;;;::::1;::::0;;;::::1;::::0;;63595:103::o;54019:383::-;54144:38;;-1:-1:-1;;;54144:38:0;;54176:4;54144:38;;;160:51:1;54127:14:0;;-1:-1:-1;;;;;54144:23:0;;;;;133:18:1;;54144:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54127:55;;54245:51;54259:6;54267;54275:20;54245:13;:51::i;:::-;54313:10;54309:86;;;54367:16;:14;:16::i;59356:247::-;52437:10;;-1:-1:-1;;;;;52437:10:0;52423;:24;52419:49;;52456:12;;-1:-1:-1;;;52456:12:0;;;;;;;;;;;52419:49;59471:21;;;:56:::1;;-1:-1:-1::0;59496:31:0;;::::1;;59471:56;59467:84;;;59536:15;;-1:-1:-1::0;;;59536:15:0::1;;;;;;;;;;;59467:84;59573:22;;;;;;;;59579:9;;59573:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;;59573:22:0;;;-1:-1:-1;59573:22:0::1;::::0;;::::1;::::0;;::::1;::::0;;;;;;;;;;;;;::::1;::::0;;;59590:4;;;;;;59573:22;::::1;::::0;59590:4;;59573:22;59590:4;59573:22;::::1;;::::0;::::1;::::0;;;-1:-1:-1;59573:22:0;;;;-1:-1:-1;;59562:33:0;;;;59573:22;;-1:-1:-1;59562:33:0::1;::::0;59573:22;;59562:33:::1;;::::0;::::1;:::i;:::-;-1:-1:-1::0;59562:33:0::1;::::0;;::::1;::::0;;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;;;;;;;59356:247:0:o;57857:118::-;52437:10;;-1:-1:-1;;;;;52437:10:0;52423;:24;52419:49;;52456:12;;-1:-1:-1;;;52456:12:0;;;;;;;;;;;52419:49;57938:14:::1;:29:::0;;-1:-1:-1;;;;;;57938:29:0::1;-1:-1:-1::0;;;;;57938:29:0;;;::::1;::::0;;;::::1;::::0;;57857:118::o;59853:281::-;52437:10;;-1:-1:-1;;;;;52437:10:0;52423;:24;52419:49;;52456:12;;-1:-1:-1;;;52456:12:0;;;;;;;;;;;52419:49;-1:-1:-1;;;;;59966:24:0;::::1;59962:51;;59999:14;;-1:-1:-1::0;;;59999:14:0::1;;;;;;;;;;;59962:51;60024:57;60053:6;60061:10;60073:7;60024:28;:57::i;:::-;60097:29;::::0;;-1:-1:-1;;;;;5309:32:1;;5291:51;;5373:2;5358:18;;5351:34;;;60097:29:0::1;::::0;5264:18:1;60097:29:0::1;;;;;;;59853:281:::0;;;:::o;59068:169::-;52437:10;;-1:-1:-1;;;;;52437:10:0;52423;:24;52419:49;;52456:12;;-1:-1:-1;;;52456:12:0;;;;;;;;;;;52419:49;59159:70:::1;59187:15;59204:5;-1:-1:-1::0;;59159:27:0::1;:70::i;:::-;59068:169:::0;:::o;58401:256::-;52437:10;;-1:-1:-1;;;;;52437:10:0;52423;:24;52419:49;;52456:12;;-1:-1:-1;;;52456:12:0;;;;;;;;;;;52419:49;-1:-1:-1;;;;;58495:31:0;::::1;58491:58;;58535:14;;-1:-1:-1::0;;;58535:14:0::1;;;;;;;;;;;58491:58;58560:16;:36:::0;;-1:-1:-1;;;;;;58560:36:0::1;-1:-1:-1::0;;;;;58560:36:0;::::1;::::0;;::::1;::::0;;;58612:37:::1;::::0;160:51:1;;;58612:37:0::1;::::0;148:2:1;133:18;58612:37:0::1;;;;;;;;58401:256:::0;:::o;57563:194::-;52437:10;;-1:-1:-1;;;;;52437:10:0;52423;:24;52419:49;;52456:12;;-1:-1:-1;;;52456:12:0;;;;;;;;;;;52419:49;49908:6:::1;57646:11;:25;57642:52;;;57680:14;;-1:-1:-1::0;;;57680:14:0::1;;;;;;;;;;;57642:52;57724:10;:24:::0;;;57710:39:::1;::::0;2712:25:1;;;57710:39:0::1;::::0;2700:2:1;2685:18;57710:39:0::1;2566:177:1::0;62572:676:0;62750:17;:43;;;;-1:-1:-1;62771:8:0;;-1:-1:-1;;;;;62771:8:0;:22;;62750:43;62746:103;;;62828:8;;62810:27;;-1:-1:-1;;;;;62828:8:0;62810:17;:27::i;:::-;62961:16;;62943:66;;-1:-1:-1;;;62943:66:0;;60584:42;62943:66;;;160:51:1;-1:-1:-1;;;;;62961:16:0;;;;62943:54;;133:18:1;;62943:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;63101:16:0;;63072:66;;-1:-1:-1;;;63072:66:0;;-1:-1:-1;;;;;63101:16:0;;;63072:66;;;5636:34:1;-1:-1:-1;;;;;5686:18:1;;;5679:43;63132:4:0;5738:18:1;;;5731:43;63080:6:0;63072:28;;;;-1:-1:-1;63072:28:0;;-1:-1:-1;5571:18:1;;63072:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63189:51;-1:-1:-1;;;;;63207:10:0;63219:20;63189:12;:51::i;:::-;62572:676;;;:::o;57463:92::-;-1:-1:-1;;;;;;;;;;;;;;;;;57532:15:0;;;57539:8;57532:15;;;;;;;;;;;;;;;;;;;;57539:8;;57532:15;;;;57539:8;;57532:15;;57539:8;57532:15;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;57532:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57463:92;:::o;58082:136::-;52437:10;;-1:-1:-1;;;;;52437:10:0;52423;:24;52419:49;;52456:12;;-1:-1:-1;;;52456:12:0;;;;;;;;;;;52419:49;58183:11:::1;:26:::0;;-1:-1:-1;;;;;;58183:26:0::1;-1:-1:-1::0;;;;;58183:26:0;::::1;::::0;;::::1;::::0;;;58168:42:::1;::::0;160:51:1;;;58168:42:0::1;::::0;148:2:1;133:18;58168:42:0::1;14:203:1::0;54816:675:0;54933:33;54944:12;54958:7;54933:10;:33::i;:::-;;54983:20;:49;;;;-1:-1:-1;55007:11:0;;-1:-1:-1;;;;;55007:11:0;:25;;54983:49;54979:324;;;55259:11;;55246:45;;-1:-1:-1;;;55246:45:0;;-1:-1:-1;;;;;178:32:1;;;55246:45:0;;;160:51:1;55259:11:0;;;;55246:31;;133:18:1;;55246:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54979:324;55325:44;;-1:-1:-1;;;55325:44:0;;55363:4;55325:44;;;160:51:1;-1:-1:-1;;;;;55325:29:0;;;;;133:18:1;;55325:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55315:54;;55386:7;55397:1;55386:12;55382:25;;54816:675;;;:::o;55382:25::-;55417:66;;-1:-1:-1;;;55417:66:0;;-1:-1:-1;;;;;5309:32:1;;;55417:66:0;;;5291:51:1;5358:18;;;5351:34;;;55433:5:0;55417:43;;;;5264:18:1;;55417:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55544:163;55594:14;;-1:-1:-1;;;;;55594:14:0;:28;55590:110;;55655:14;;55639:49;;-1:-1:-1;;;55639:49:0;;-1:-1:-1;;;;;55682:5:0;178:32:1;;55639:49:0;;;160:51:1;55655:14:0;;;;55639:42;;133:18:1;;55639:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55590:110;55544:163::o;38865:1213::-;39031:2;39025:4;39018:16;39089:6;39083:4;39076:20;-1:-1:-1;;;39225:4:0;39218:48;39696:4;39690;39684;39678;39675:1;39668:5;39661;39656:45;39615:16;39608:24;39604:1;39597:4;39591:11;39588:18;39585:48;39310:410;39282:667;;39839:10;39833:4;39826:24;39929:4;39923;39916:18;39282:667;40058:1;40052:4;40045:15;38865:1213;;;:::o;42293:1210::-;42458:2;42452:4;42445:16;42516:6;42510:4;42503:20;-1:-1:-1;;;42651:4:0;42644:48;43122:4;43116;43110;43104;43101:1;43094:5;43087;43082:45;43041:16;43034:24;43030:1;43023:4;43017:11;43014:18;43011:48;42736:410;42708:666;;43264:10;43258:4;43251:24;43354:4;43348;43341:18;56795:504;56984:46;;;;;;;;;;;;;;;;-1:-1:-1;;;;;56984:46:0;-1:-1:-1;;;56984:46:0;;;56969:62;;56928:12;;;;-1:-1:-1;;;;;56969:14:0;;;:62;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56927:104;;;;57049:7;57044:248;;57077:10;:17;57098:1;57077:22;57073:58;;57101:30;;-1:-1:-1;;;57101:30:0;;6404:2:1;57101:30:0;;;6386:21:1;6443:2;6423:18;;;6416:30;-1:-1:-1;;;6462:18:1;;;6455:50;6522:18;;57101:30:0;;;;;;;57073:58;57202:10;57197:2;57185:10;57181:19;57174:39;55867:635;55938:16;55971:7;55982:1;55971:12;55967:26;;-1:-1:-1;55992:1:0;55985:8;;55967:26;56006:22;56031:13;:11;:13::i;:::-;56006:38;-1:-1:-1;56055:11:0;;56077:245;56101:19;;:26;56097:30;;56077:245;;;49908:6;56166:9;:14;;;56181:1;56166:17;;;;;;;;:::i;:::-;;;;;;;56156:7;:27;;;;:::i;:::-;56155:43;;;;:::i;:::-;56149:49;;56213:65;56242:6;56250:9;:19;;;56270:1;56250:22;;;;;;;;:::i;:::-;;;;;;;56274:3;56213:28;:65::i;:::-;56295:15;56307:3;56295:15;;:::i;:::-;;-1:-1:-1;56129:3:0;;;;:::i;:::-;;;;56077:245;;;;49908:6;56377:10;;56367:7;:20;;;;:::i;:::-;56366:36;;;;:::i;:::-;56360:42;;56413:53;56442:6;56450:10;56462:3;56413:28;:53::i;:::-;56479:15;56491:3;56479:15;;:::i;:::-;;;55956:546;;55867:635;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;222:173:1;290:20;;-1:-1:-1;;;;;339:31:1;;329:42;;319:70;;385:1;382;375:12;319:70;222:173;;;:::o;400:186::-;459:6;512:2;500:9;491:7;487:23;483:32;480:52;;;528:1;525;518:12;480:52;551:29;570:9;551:29;:::i;:::-;541:39;400:186;-1:-1:-1;;;400:186:1:o;591:160::-;656:20;;712:13;;705:21;695:32;;685:60;;741:1;738;731:12;756:322;827:6;835;843;896:2;884:9;875:7;871:23;867:32;864:52;;;912:1;909;902:12;864:52;935:29;954:9;935:29;:::i;:::-;925:39;;983:35;1014:2;1003:9;999:18;983:35;:::i;:::-;973:45;;1037:35;1068:2;1057:9;1053:18;1037:35;:::i;:::-;1027:45;;756:322;;;;;:::o;1083:367::-;1146:8;1156:6;1210:3;1203:4;1195:6;1191:17;1187:27;1177:55;;1228:1;1225;1218:12;1177:55;-1:-1:-1;1251:20:1;;1294:18;1283:30;;1280:50;;;1326:1;1323;1316:12;1280:50;1363:4;1355:6;1351:17;1339:29;;1423:3;1416:4;1406:6;1403:1;1399:14;1391:6;1387:27;1383:38;1380:47;1377:67;;;1440:1;1437;1430:12;1377:67;1083:367;;;;;:::o;1455:773::-;1577:6;1585;1593;1601;1654:2;1642:9;1633:7;1629:23;1625:32;1622:52;;;1670:1;1667;1660:12;1622:52;1710:9;1697:23;1739:18;1780:2;1772:6;1769:14;1766:34;;;1796:1;1793;1786:12;1766:34;1835:70;1897:7;1888:6;1877:9;1873:22;1835:70;:::i;:::-;1924:8;;-1:-1:-1;1809:96:1;-1:-1:-1;2012:2:1;1997:18;;1984:32;;-1:-1:-1;2028:16:1;;;2025:36;;;2057:1;2054;2047:12;2025:36;;2096:72;2160:7;2149:8;2138:9;2134:24;2096:72;:::i;:::-;1455:773;;;;-1:-1:-1;2187:8:1;-1:-1:-1;;;;1455:773:1:o;2233:328::-;2310:6;2318;2326;2379:2;2367:9;2358:7;2354:23;2350:32;2347:52;;;2395:1;2392;2385:12;2347:52;2418:29;2437:9;2418:29;:::i;:::-;2408:39;;2494:2;2483:9;2479:18;2466:32;2456:42;;2517:38;2551:2;2540:9;2536:18;2517:38;:::i;2748:391::-;2825:6;2833;2841;2849;2902:3;2890:9;2881:7;2877:23;2873:33;2870:53;;;2919:1;2916;2909:12;2870:53;2942:29;2961:9;2942:29;:::i;:::-;2932:39;;2990:35;3021:2;3010:9;3006:18;2990:35;:::i;:::-;2980:45;;3044:35;3075:2;3064:9;3060:18;3044:35;:::i;:::-;3034:45;;3098:35;3129:2;3118:9;3114:18;3098:35;:::i;:::-;3088:45;;2748:391;;;;;;;:::o;3144:180::-;3203:6;3256:2;3244:9;3235:7;3231:23;3227:32;3224:52;;;3272:1;3269;3262:12;3224:52;-1:-1:-1;3295:23:1;;3144:180;-1:-1:-1;3144:180:1:o;3329:316::-;3397:6;3405;3413;3466:2;3454:9;3445:7;3441:23;3437:32;3434:52;;;3482:1;3479;3472:12;3434:52;3505:26;3521:9;3505:26;:::i;3650:1273::-;3815:2;3826:21;;;3917:13;;3966:4;3946:18;;;3939:32;4020:19;;3885:2;3870:18;;4048:22;;;3786:4;;3815:2;4128:21;;;3786:4;;4101:3;4086:19;;;4177:195;4191:6;4188:1;4185:13;4177:195;;;4256:13;;-1:-1:-1;;;;;4252:39:1;4240:52;;4347:15;;;;4288:1;4206:9;;;;;4312:12;;;;4177:195;;;-1:-1:-1;4409:15:1;;;4403:22;4467:19;;;-1:-1:-1;;4463:33:1;4456:4;4441:20;;4434:63;4547:21;;4577;;;4653:23;;;;-1:-1:-1;4616:12:1;;;;-1:-1:-1;4696:1:1;;4706:189;4722:8;4717:3;4714:17;4706:189;;;4791:15;;4777:30;;4868:17;;;;4829:14;;;;4750:1;4741:11;;;;;4706:189;;;-1:-1:-1;4912:5:1;;3650:1273;-1:-1:-1;;;;;;3650:1273:1:o;4928:184::-;4998:6;5051:2;5039:9;5030:7;5026:23;5022:32;5019:52;;;5067:1;5064;5057:12;5019:52;-1:-1:-1;5090:16:1;;4928:184;-1:-1:-1;4928:184:1:o;5785:412::-;5914:3;5952:6;5946:13;5977:1;5987:129;6001:6;5998:1;5995:13;5987:129;;;6099:4;6083:14;;;6079:25;;6073:32;6060:11;;;6053:53;6016:12;5987:129;;;-1:-1:-1;6171:1:1;6135:16;;6160:13;;;-1:-1:-1;6135:16:1;5785:412;-1:-1:-1;5785:412:1:o;6551:127::-;6612:10;6607:3;6603:20;6600:1;6593:31;6643:4;6640:1;6633:15;6667:4;6664:1;6657:15;6683:127;6744:10;6739:3;6735:20;6732:1;6725:31;6775:4;6772:1;6765:15;6799:4;6796:1;6789:15;6815:168;6888:9;;;6919;;6936:15;;;6930:22;;6916:37;6906:71;;6957:18;;:::i;6988:217::-;7028:1;7054;7044:132;;7098:10;7093:3;7089:20;7086:1;7079:31;7133:4;7130:1;7123:15;7161:4;7158:1;7151:15;7044:132;-1:-1:-1;7190:9:1;;6988:217::o;7210:125::-;7275:9;;;7296:10;;;7293:36;;;7309:18;;:::i;7340:135::-;7379:3;7400:17;;;7397:43;;7420:18;;:::i;:::-;-1:-1:-1;7467:1:1;7456:13;;7340:135::o

ipfs://e21ee403ff5d5de9cf29e32b3ad4f70b71e030b323fb432312eff6555b178552