**Use case**

Convert bitmask to position.
It would allow us to directly use FLAT dictionary or Enum datatype without jumping around slow `bitmasktoArray` and `arrayMap`

**Describe the solution you'd like**

```
SELECT
    arrayMap(x -> log2(x), bitmaskToArray(100)) AS bitmask,
    bitPositions(100)  AS bitpositions

┌─bitmask─┬─bitpositions─┐
│ [2,5,6] │ [2,5,6]      │
└─────────┴──────────────┘
```

}
        else if (const auto * col_in_fixed = checkAndGetColumn<ColumnFixedString>(column.get()))
        {
            if (col_in_fixed->getN() != uuid_text_length)
                throw Exception("Illegal type " + col_type_name.type->getName() +
                                " of column " + col_in_fixed->getName() +
                                " argument of function " + getName() +
                                ", expected FixedString(" + toString(uuid_text_length) + ")",
                                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
            const auto size = col_in_fixed->size();
            const auto & vec_in = col_in_fixed->getChars();
            auto col_res = ColumnFixedString::create(uuid_bytes_length);
            ColumnString::Chars & vec_res = col_res->getChars();
            vec_res.resize(size * uuid_bytes_length);
            size_t src_offset = 0;
            size_t dst_offset = 0;
            for (size_t i = 0; i < size; ++i)
            {
                parseUUID(&vec_in[src_offset], &vec_res[dst_offset]);
                src_offset += uuid_text_length;
                dst_offset += uuid_bytes_length;
            }
            return col_res;
        }
        else
            throw Exception("Illegal column " + arguments[0].column->getName()
                + " of argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
    }
};
class FunctionHex : public IFunction