// File: /workspace/github_cpp_makefile_star2_O2/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 0xba1f
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
cmpq %rcx, %rax
je 0xbabc
movq 0x10(%rdi), %r9
movq 0x30(%rdi), %rdx
addq $0x10, %rax
movq %rsi, %r8
movq 0x8(%rdi), %r10
subq %r9, %r10
subq %r10, %r8
jl 0xba87
addq %r10, %rdx
movq %rdx, 0x30(%rdi)
movq %rax, 0x20(%rdi)
cmpq %rcx, %rax
je 0xba97
movups (%rax), %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
addq $0x10, %rax
xorl %r9d, %r9d
movq %r8, %rsi
jmp 0xb9e4
jns 0xbaa7
negq %rsi
movq 0x30(%rdi), %rax
cmpq %rsi, %rax
jb 0xbafa
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %r8
movq %rdx, %r9
subq %rsi, %r9
jae 0xbaa9
subq %rdx, %rsi
subq %rdx, %rax
movq %rax, 0x30(%rdi)
movq %r8, %r9
cmpq %rcx, %r8
je 0xbab2
cmpq %rcx, %r9
je 0xba41
movq -0x8(%r9), %r10
addq $-0x10, %r9
testq %r10, %r10
je 0xba5b
movq (%r9), %rdx
movq %r9, 0x20(%rdi)
movq %rdx, (%rdi)
movq %r10, 0x8(%rdi)
movq %r10, 0x10(%rdi)
movq %r10, %rdx
movq %r9, %r8
jmp 0xba41
addq %rsi, %rdx
movq %rdx, 0x30(%rdi)
addq %rsi, %r9
movq %r9, 0x10(%rdi)
jmp 0xbaa7
testq %r8, %r8
jne 0xbadb
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
popq %rax
retq
subq %rsi, %rax
movq %rax, 0x30(%rdi)
jmp 0xba91
testq %rsi, %rsi
jne 0xbb19
xorl %r9d, %r9d
jmp 0xba91
leaq 0xba6(%rip), %rdi       # 0xc669
leaq 0xbcc(%rip), %rsi       # 0xc696
leaq 0xbe9(%rip), %rcx       # 0xc6ba
movl $0x19b, %edx            # imm = 0x19B
callq 0x5240
leaq 0xc91(%rip), %rdi       # 0xc773
leaq 0xbad(%rip), %rsi       # 0xc696
leaq 0xbca(%rip), %rcx       # 0xc6ba
movl $0x1b1, %edx            # imm = 0x1B1
callq 0x5240
leaq 0xc3f(%rip), %rdi       # 0xc740
leaq 0xb8e(%rip), %rsi       # 0xc696
leaq 0xbab(%rip), %rcx       # 0xc6ba
movl $0x1bd, %edx            # imm = 0x1BD
callq 0x5240
leaq 0xc4f(%rip), %rdi       # 0xc76f
leaq 0xb6f(%rip), %rsi       # 0xc696
leaq 0xb8c(%rip), %rcx       # 0xc6ba
movl $0x1cf, %edx            # imm = 0x1CF
callq 0x5240