# encoding: utf-8
# module bitarray._util
# from C:\Programs\Python\Python313\Lib\site-packages\bitarray\_util.cp313-win_amd64.pyd
# by generator 1.147
# no doc
# no imports

# functions

def any_and(a, b, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    any_and(a, b, /) -> bool
    
    Efficient implementation of `any(a & b)`.
    """
    pass

def ba2base(n, bitarray, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    ba2base(n, bitarray, /, group=0, sep=' ') -> str
    
    Return a string containing the base `n` ASCII representation of
    the bitarray.  Allowed values for `n` are 2, 4, 8, 16, 32 and 64.
    The bitarray has to be multiple of length 1, 2, 3, 4, 5 or 6 respectively.
    For `n=32` the RFC 4648 Base32 alphabet is used, and for `n=64` the
    standard base 64 alphabet is used.
    When grouped, the string `sep` is inserted between groups
    of `group` characters, default is a space.
    """
    pass

def ba2hex(bitarray, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    ba2hex(bitarray, /, group=0, sep=' ') -> hexstr
    
    Return a string containing the hexadecimal representation of
    the bitarray (which has to be multiple of 4 in length).
    When grouped, the string `sep` is inserted between groups
    of `group` characters, default is a space.
    """
    pass

def base2ba(n, asciistr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    base2ba(n, asciistr, /, endian=None) -> bitarray
    
    Bitarray of base `n` ASCII representation.
    Allowed values for `n` are 2, 4, 8, 16, 32 and 64.
    For `n=32` the RFC 4648 Base32 alphabet is used, and for `n=64` the
    standard base 64 alphabet is used.  Whitespace is ignored.
    """
    pass

def byteswap(a, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    byteswap(a, /, n=<buffer size>)
    
    Reverse every `n` consecutive bytes of `a` in-place.
    By default, all bytes are reversed.  Note that `n` is not limited to 2, 4
    or 8, but can be any positive integer.
    Also, `a` may be any object that exposes a writeable buffer.
    Nothing about this function is specific to bitarray objects.
    """
    pass

def canonical_decode(bitarray, count, symbol, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    canonical_decode(bitarray, count, symbol, /) -> iterator
    
    Decode bitarray using canonical Huffman decoding tables
    where `count` is a sequence containing the number of symbols of each length
    and `symbol` is a sequence of symbols in canonical order.
    """
    pass

def correspond_all(a, b, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    correspond_all(a, b, /) -> tuple
    
    Return tuple with counts of: ~a & ~b, ~a & b, a & ~b, a & b
    """
    pass

def count_and(a, b, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    count_and(a, b, /) -> int
    
    Return `(a & b).count()` in a memory efficient manner,
    as no intermediate bitarray object gets created.
    """
    pass

def count_n(a, n, value=1, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    count_n(a, n, value=1, /) -> int
    
    Return lowest index `i` for which `a[:i].count(value) == n`.
    Raises `ValueError` when `n` exceeds total count (`a.count(value)`).
    """
    pass

def count_or(a, b, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    count_or(a, b, /) -> int
    
    Return `(a | b).count()` in a memory efficient manner,
    as no intermediate bitarray object gets created.
    """
    pass

def count_xor(a, b, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    count_xor(a, b, /) -> int
    
    Return `(a ^ b).count()` in a memory efficient manner,
    as no intermediate bitarray object gets created.
    """
    pass

def deserialize(bytes, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    deserialize(bytes, /) -> bitarray
    
    Return a bitarray given a bytes-like representation such as returned
    by `serialize()`.
    """
    pass

def hex2ba(hexstr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    hex2ba(hexstr, /, endian=None) -> bitarray
    
    Bitarray of hexadecimal representation.  hexstr may contain any number
    (including odd numbers) of hex digits (upper or lower case).
    Whitespace is ignored.
    """
    pass

def ones(n, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    ones(n, /, endian=None) -> bitarray
    
    Create a bitarray of length `n`, with all values `1`, and optional
    bit-endianness (`little` or `big`).
    """
    pass

def parity(a, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    parity(a, /) -> int
    
    Return parity of bitarray `a`.
    `parity(a)` is equivalent to `a.count() % 2` but more efficient.
    """
    pass

def sc_decode(stream): # real signature unknown; restored from __doc__
    """
    sc_decode(stream) -> bitarray
    
    Decompress binary stream (an integer iterator, or bytes-like object) of a
    sparse compressed (`sc`) bitarray, and return the decoded  bitarray.
    This function consumes only one bitarray and leaves the remaining stream
    untouched.  Use `sc_encode()` for compressing (encoding).
    """
    pass

def sc_encode(bitarray, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    sc_encode(bitarray, /) -> bytes
    
    Compress a sparse bitarray and return its binary representation.
    This representation is useful for efficiently storing sparse bitarrays.
    Use `sc_decode()` for decompressing (decoding).
    """
    pass

def serialize(bitarray, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    serialize(bitarray, /) -> bytes
    
    Return a serialized representation of the bitarray, which may be passed to
    `deserialize()`.  It efficiently represents the bitarray object (including
    its bit-endianness) and is guaranteed not to change in future releases.
    """
    pass

def subset(a, b, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    subset(a, b, /) -> bool
    
    Return `True` if bitarray `a` is a subset of bitarray `b`.
    `subset(a, b)` is equivalent to `a | b == b` (and equally `a & b == a`) but
    more efficient as no intermediate bitarray object is created and the buffer
    iteration is stopped as soon as one mismatch is found.
    """
    pass

def vl_decode(stream, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    vl_decode(stream, /, endian=None) -> bitarray
    
    Decode binary stream (an integer iterator, or bytes-like object), and
    return the decoded bitarray.  This function consumes only one bitarray and
    leaves the remaining stream untouched.  Use `vl_encode()` for encoding.
    """
    pass

def vl_encode(bitarray, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    vl_encode(bitarray, /) -> bytes
    
    Return variable length binary representation of bitarray.
    This representation is useful for efficiently storing small bitarray
    in a binary stream.  Use `vl_decode()` for decoding.
    """
    pass

def xor_indices(a, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    xor_indices(a, /) -> int
    
    Return xor reduced indices of all active bits in bitarray `a`.
    This is essentially equivalent to
    `reduce(operator.xor, [i for i, v in enumerate(a) if v])`.
    """
    pass

def zeros(n, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
    """
    zeros(n, /, endian=None) -> bitarray
    
    Create a bitarray of length `n`, with all values `0`, and optional
    bit-endianness (`little` or `big`).
    """
    pass

# no classes
# variables with complex values

__loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x00000158610796A0>'

__spec__ = None # (!) real value is "ModuleSpec(name='bitarray._util', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x00000158610796A0>, origin='C:\\\\Programs\\\\Python\\\\Python313\\\\Lib\\\\site-packages\\\\bitarray\\\\_util.cp313-win_amd64.pyd')"