pragma solidity ^0.8.13;

contract CapabilityBitset {
    mapping(address => uint256) private _mask;
    uint256 private claimedMask;
    mapping(uint8 => address) public lead;

    function register(uint256 bits) external {
        uint256 fresh = bits & ~_mask[msg.sender];
        _mask[msg.sender] |= bits;
        uint256 newlyClaimed = fresh & ~claimedMask;
        if (newlyClaimed != 0) {
            claimedMask |= newlyClaimed;
            while (newlyClaimed != 0) {
                uint256 lsb = newlyClaimed & (~newlyClaimed + 1);
                lead[bitIndex(lsb)] = msg.sender;
                newlyClaimed ^= lsb;
            }
        }
    }

    function query(address agent, uint256 needed) external view returns (bool) {
        return (_mask[agent] & needed) == needed;
    }

    // Convert an isolated least-significant bit (power of two) to its index.
    function bitIndex(uint256 x) private pure returns (uint8 r) {
        unchecked {
            if (x & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0) { x >>= 128; r += 128; }
            if (x & 0xFFFFFFFFFFFFFFFF == 0) { x >>= 64; r += 64; }
            if (x & 0xFFFFFFFF == 0) { x >>= 32; r += 32; }
            if (x & 0xFFFF == 0) { x >>= 16; r += 16; }
            if (x & 0xFF == 0) { x >>= 8; r += 8; }
            if (x & 0xF == 0) { x >>= 4; r += 4; }
            if (x & 0x3 == 0) { x >>= 2; r += 2; }
            if (x & 0x1 == 0) { r += 1; }
        }
    }
}