def METHOD_NAME(r, c, _input, suffix, output_len):
    """
    The general sponge function, consisting of the inner permutation and a
    padding rule (`pad10*1`). It consists of three main parts.
        * absorbing, where the input will be permuted repeatedly every time
            it is divided into a block of size `r + c`.
        * padding, where an oddly sized last block will be filled with bits
            until it can be fed into the permutation.
        * squeezing, where the output's blocks will be permuted more times
            until they are concatenated to the desired size.
    Args:
        r:          rate, or the number of input bits processed or output bits
                    generated per invocation of the underlying function
        c:          capacity, or the width of the underlying function minus
                    the rate
        _input:     list of bytes containing the desired object to be hashed
        suffix:     distinguishes the inputs arising from SHA-3/SHAKE functions
        output_len: length of hash output.
    Returns:
        Hash of the input bytes.
    """
    state = bytearray((r + c) // 8)
    rate_bytes, block, offset = r // 8, 0, 0
    while offset < len(_input):
        block = min(len(_input) - offset, rate_bytes)
        for i in range(block):
            state[i] ^= _input[i + offset]
        offset += block
        if block == rate_bytes:
            state = keccak_f_1600(state)
            block = 0
    state[block] ^= suffix
    if (suffix & 0x80) and (block == (rate_bytes - 1)):
        state = keccak_f_1600(state)
    state[rate_bytes - 1] ^= 0x80
    state = keccak_f_1600(state)
    output = bytearray()
    while output_len:
        block = min(output_len, rate_bytes)
        output += state[:block]
        output_len -= block
        if output_len:
            state = keccak_f_1600(state)
    return output