// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/./include/asio/buffers_iterator.hpp
// Function: asio::buffers_iterator<asio::const_buffers_1, char>::advance(long)
void advance(std::ptrdiff_t n)
  {
    if (n > 0)
    {
      ASIO_ASSERT(current_ != end_ && "iterator out of bounds");
      for (;;)
      {
        std::ptrdiff_t current_buffer_balance
          = current_buffer_.size() - current_buffer_position_;

        // Check if the advance can be satisfied by the current buffer.
        if (current_buffer_balance > n)
        {
          position_ += n;
          current_buffer_position_ += n;
          return;
        }

        // Update position.
        n -= current_buffer_balance;
        position_ += current_buffer_balance;

        // Move to next buffer. If it is empty then it will be skipped on the
        // next iteration of this loop.
        if (++current_ == end_)
        {
          ASIO_ASSERT(n == 0 && "iterator out of bounds");
          current_buffer_ = buffer_type();
          current_buffer_position_ = 0;
          return;
        }
        current_buffer_ = *current_;
        current_buffer_position_ = 0;
      }
    }
    else if (n < 0)
    {
      std::size_t abs_n = -n;
      ASIO_ASSERT(position_ >= abs_n && "iterator out of bounds");
      for (;;)
      {
        // Check if the advance can be satisfied by the current buffer.
        if (current_buffer_position_ >= abs_n)
        {
          position_ -= abs_n;
          current_buffer_position_ -= abs_n;
          return;
        }

        // Update position.
        abs_n -= current_buffer_position_;
        position_ -= current_buffer_position_;

        // Check if we've reached the beginning of the buffers.
        if (current_ == begin_)
        {
          ASIO_ASSERT(abs_n == 0 && "iterator out of bounds");
          current_buffer_position_ = 0;
          return;
        }

        // Find the previous non-empty buffer.
        buffer_sequence_iterator_type iter = current_;
        while (iter != begin_)
        {
          --iter;
          buffer_type buffer = *iter;
          std::size_t buffer_size = buffer.size();
          if (buffer_size > 0)
          {
            current_ = iter;
            current_buffer_ = buffer;
            current_buffer_position_ = buffer_size;
            break;
          }
        }
      }
    }
  }

// Assembly:
pushq %rax
testq %rsi, %rsi
jle 0xd118
movq 0x20(%rdi), %rdx
movq 0x28(%rdi), %r8
cmpq %r8, %rdx
je 0xd1b9
movq 0x8(%rdi), %r9
movq 0x10(%rdi), %rax
subq %rax, %r9
movq 0x30(%rdi), %rcx
cmpq %rsi, %r9
jg 0xd105
addq $0x10, %rdx
xorl %eax, %eax
subq %r9, %rsi
addq %r9, %rcx
movq %rcx, 0x30(%rdi)
movq %rdx, 0x20(%rdi)
cmpq %r8, %rdx
je 0xd187
movups (%rdx), %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rdi), %r9
addq $0x10, %rdx
cmpq %rsi, %r9
jle 0xd0d3
addq %rsi, %rcx
movq %rcx, 0x30(%rdi)
addq %rsi, %rax
movq %rax, 0x10(%rdi)
jmp 0xd1b7
jns 0xd1b7
negq %rsi
movq 0x30(%rdi), %rax
cmpq %rsi, %rax
jb 0xd1f7
movq 0x10(%rdi), %rdx
cmpq %rsi, %rdx
jae 0xd19c
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %r8
subq %rdx, %rsi
subq %rdx, %rax
movq %rax, 0x30(%rdi)
movq %r8, %r10
cmpq %rcx, %r8
je 0xd1ab
cmpq %rcx, %r10
je 0xd17d
movq -0x8(%r10), %r9
addq $-0x10, %r10
testq %r9, %r9
je 0xd151
movq (%r10), %rdx
movq %r10, 0x20(%rdi)
movq %rdx, (%rdi)
movq %r9, 0x8(%rdi)
movq %r9, 0x10(%rdi)
movq %r10, %r8
movq %r9, %rdx
jmp 0xd180
movq %rdx, %r9
cmpq %rsi, %r9
jb 0xd13f
jmp 0xd19f
testq %rsi, %rsi
jne 0xd1d8
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
jmp 0xd1b7
movq %rdx, %r9
subq %rsi, %rax
movq %rax, 0x30(%rdi)
subq %rsi, %r9
jmp 0xd1b3
testq %rsi, %rsi
jne 0xd216
xorl %r9d, %r9d
movq %r9, 0x10(%rdi)
popq %rax
retq
leaq 0x14d3(%rip), %rdi      # 0xe693
leaq 0x14f9(%rip), %rsi      # 0xe6c0
leaq 0x1516(%rip), %rcx      # 0xe6e4
movl $0x19b, %edx            # imm = 0x19B
callq 0x5200
leaq 0x15be(%rip), %rdi      # 0xe79d
leaq 0x14da(%rip), %rsi      # 0xe6c0
leaq 0x14f7(%rip), %rcx      # 0xe6e4
movl $0x1b1, %edx            # imm = 0x1B1
callq 0x5200
leaq 0x156c(%rip), %rdi      # 0xe76a
leaq 0x14bb(%rip), %rsi      # 0xe6c0
leaq 0x14d8(%rip), %rcx      # 0xe6e4
movl $0x1bd, %edx            # imm = 0x1BD
callq 0x5200
leaq 0x157c(%rip), %rdi      # 0xe799
leaq 0x149c(%rip), %rsi      # 0xe6c0
leaq 0x14b9(%rip), %rcx      # 0xe6e4
movl $0x1cf, %edx            # imm = 0x1CF
callq 0x5200
nop