// File: /workspace/github_cpp_makefile_star2_O1/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 0xd32e
movq 0x28(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0xd3d7
movq 0x10(%rdi), %r8
movq 0x20(%rdi), %rcx
movq 0x30(%rdi), %rdx
xorps %xmm0, %xmm0
movq 0x8(%rdi), %r9
subq %r8, %r9
movq %rsi, %r10
subq %r9, %r10
jge 0xd2e7
addq %rsi, %rdx
movq %rdx, 0x30(%rdi)
addq %rsi, %r8
xorl %r9d, %r9d
jmp 0xd320
addq %r9, %rdx
movq %rdx, 0x30(%rdi)
addq $0x10, %rcx
movq %rcx, 0x20(%rdi)
cmpq %rax, %rcx
je 0xd30c
movups (%rcx), %xmm1
movups %xmm1, (%rdi)
movb $0x1, %r9b
xorl %r8d, %r8d
movq %r10, %rsi
jmp 0xd320
testq %r10, %r10
jne 0xd3b8
movups %xmm0, (%rdi)
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %esi, %esi
movq %r8, 0x10(%rdi)
testb %r9b, %r9b
jne 0xd2c9
jmp 0xd3b6
jns 0xd3b6
negq %rsi
cmpq %rsi, 0x30(%rdi)
jb 0xd3f6
movq 0x10(%rdi), %rdx
cmpq %rsi, %rdx
jae 0xd39e
movq 0x30(%rdi), %rax
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 0xd3aa
cmpq %rcx, %r10
je 0xd394
movq -0x8(%r10), %r9
addq $-0x10, %r10
testq %r9, %r9
je 0xd368
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 0xd397
movq %rdx, %r9
cmpq %rsi, %r9
jb 0xd356
jmp 0xd3a1
movq %rdx, %r9
subq %rsi, 0x30(%rdi)
subq %rsi, %r9
jmp 0xd3b2
testq %rsi, %rsi
jne 0xd415
xorl %r9d, %r9d
movq %r9, 0x10(%rdi)
popq %rax
retq
leaq 0x13de(%rip), %rdi      # 0xe79d
leaq 0x12fa(%rip), %rsi      # 0xe6c0
leaq 0x1317(%rip), %rcx      # 0xe6e4
movl $0x1b1, %edx            # imm = 0x1B1
callq 0x5200
leaq 0x12b5(%rip), %rdi      # 0xe693
leaq 0x12db(%rip), %rsi      # 0xe6c0
leaq 0x12f8(%rip), %rcx      # 0xe6e4
movl $0x19b, %edx            # imm = 0x19B
callq 0x5200
leaq 0x136d(%rip), %rdi      # 0xe76a
leaq 0x12bc(%rip), %rsi      # 0xe6c0
leaq 0x12d9(%rip), %rcx      # 0xe6e4
movl $0x1bd, %edx            # imm = 0x1BD
callq 0x5200
leaq 0x137d(%rip), %rdi      # 0xe799
leaq 0x129d(%rip), %rsi      # 0xe6c0
leaq 0x12ba(%rip), %rcx      # 0xe6e4
movl $0x1cf, %edx            # imm = 0x1CF
callq 0x5200