// File: /workspace/github_cpp_makefile_star2_O2/lukasz-wiecaszek[P]h264iframedecoder/./istream.hpp
// Function: ymn::istream<0>::peek_bits(unsigned int, unsigned int&)
bool peek_bits(uint32_t number_of_bits, uint32_t& value)
    {
        assert(number_of_bits <= 32);

        /* verify whether we don't go beyond size of the stream */
        if ((m_position.to_bits() + number_of_bits) <= (m_size * BITS_PER_BYTE)) {

            uint32_t v = 0;
            uint32_t bits_remaining = number_of_bits;
            uint32_t bits_to_read;

            uint32_t byte_pos = m_position.m_byte_position;
            uint32_t bit_pos = m_position.m_bit_position;

            while (bits_remaining > 0) {
                /* there is more bits to be peeked than bits left in current byte */
                if ((bit_pos + bits_remaining) >= BITS_PER_BYTE) {
                    /* number of bits left in current byte */
                    bits_to_read = BITS_PER_BYTE - bit_pos;

                    /* shift the result by number of bits to be peeked
                    to make room for new data */
                    v <<= bits_to_read;
                    /* add to the result value */
                    v |= m_buffer[byte_pos] & ((1U << bits_to_read) - 1);

                    /* move to the next byte in the stream */
                    byte_pos++;
                    /* and reset bit position to the begining of a byte */
                    bit_pos = 0;
                }
                else {
                    /* there remains less than 8 bits to be peeked */
                    bits_to_read = bits_remaining;

                    /* shift the result by number of bits to be peeked
                    to make room for new data */
                    v <<= bits_to_read;

                    /* advance bit position */
                    bit_pos += bits_to_read;

                    /* add to the result value */
                    v |= (m_buffer[byte_pos] >> (BITS_PER_BYTE - bit_pos)) & ((1U << bits_to_read) - 1);
                }

                /* decrease the number of remaining bits by number of bits peeked in this iteration */
                bits_remaining -= bits_to_read;
            }

            value = v;
            return true;
        }
        else {
            m_status |= ISTREAM_STATUS_EOS_REACHED;
            if (m_error_function)
                m_error_function(m_position, m_position + number_of_bits);
            return false;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x21, %esi
jae 0x68aa
movl %esi, %eax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %r14
movl %esi, %esi
leaq (%r14,%rsi), %rcx
leaq (%rcx,%rdi,8), %r12
shlq $0x3, %r15
cmpq %r15, %r12
ja 0x6860
movq (%rbx), %r8
xorl %esi, %esi
pushq $0x8
popq %r9
pushq $-0x1
popq %r10
testl %eax, %eax
je 0x6895
leal (%r14,%rax), %r11d
movl %edi, %ebx
cmpl $0x8, %r11d
jb 0x683a
movl %r9d, %ecx
subl %r14d, %ecx
shll %cl, %esi
movzbl (%r8,%rbx), %r11d
movl %r10d, %ebx
shll %cl, %ebx
notl %ebx
andl %r11d, %ebx
orl %ebx, %esi
incl %edi
xorl %r11d, %r11d
jmp 0x6859
movl %eax, %ecx
shll %cl, %esi
movzbl (%r8,%rbx), %ebx
movb $0x8, %cl
subb %r11b, %cl
shrl %cl, %ebx
movl %r10d, %ebp
movl %eax, %ecx
shll %cl, %ebp
notl %ebp
andl %ebx, %ebp
orl %ebp, %esi
movl %eax, %ecx
subl %ecx, %eax
movl %r11d, %r14d
jmp 0x6806
orb $0x1, 0x20(%rbx)
cmpq $0x0, 0x38(%rbx)
je 0x6897
leaq 0x10(%rbx), %r14
addq $0x28, %rbx
movq %r14, %rdi
callq 0x68dd
movq %rsp, %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rcx, %rdx
callq 0x68ca
jmp 0x6897
movl %esi, (%rdx)
cmpq %r15, %r12
setbe %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe560(%rip), %rdi      # 0x14e11
leaq 0xe56e(%rip), %rsi      # 0x14e26
leaq 0xe575(%rip), %rcx      # 0x14e34
movl $0x1eb, %edx            # imm = 0x1EB
callq 0x20d0
nop