// File: benjibc[P]json-universal-container/./boost_file/boost/container/vector.hpp
// Function: boost::container::vector<JSON, std::allocator<JSON>>::priv_range_insert_expand_backwards(JSON*, unsigned long, JSON*, unsigned long, boost::container::container_detail::advanced_insert_aux_int<JSON*>&)
void priv_range_insert_expand_backwards
         (T* new_start, size_type new_capacity,
          T* pos, const size_type n, advanced_insert_aux_int_t &interf)
   {
      //n can be zero to just expand capacity
      //Backup old data
      T* old_start  = container_detail::to_raw_pointer(this->members_.m_start);
      T* old_finish = old_start + this->members_.m_size;
      size_type old_size = this->members_.m_size;

      //We can have 8 possibilities:
      const size_type elemsbefore   = (size_type)(pos - old_start);
      const size_type s_before      = (size_type)(old_start - new_start);

      //Update the vector buffer information to a safe state
      this->members_.m_start      = new_start;
      this->members_.m_capacity   = new_capacity;
      this->members_.m_size = 0;

      //If anything goes wrong, this object will destroy
      //all the old objects to fulfill previous vector state
      typename value_traits::OldArrayDestructor old_values_destroyer(old_start, this->alloc(), old_size);
      //Check if s_before is big enough to hold the beginning of old data + new data
      if(difference_type(s_before) >= difference_type(elemsbefore + n)){
         //Copy first old values before pos, after that the new objects
         ::boost::container::uninitialized_move_alloc(this->alloc(), old_start, pos, new_start);
         this->members_.m_size = elemsbefore;
         interf.uninitialized_copy_remaining_to(new_start + elemsbefore);
         this->members_.m_size += n;
         //Check if s_before is so big that even copying the old data + new data
         //there is a gap between the new data and the old data
         if(s_before >= (old_size + n)){
            //Old situation:
            // _________________________________________________________
            //|            raw_mem                | old_begin | old_end |
            //| __________________________________|___________|_________|
            //
            //New situation:
            // _________________________________________________________
            //| old_begin |    new   | old_end |         raw_mem        |
            //|___________|__________|_________|________________________|
            //
            //Now initialize the rest of memory with the last old values
            ::boost::container::uninitialized_move_alloc
               (this->alloc(), pos, old_finish, new_start + elemsbefore + n);
            //All new elements correctly constructed, avoid new element destruction
            this->members_.m_size = old_size + n;
            //Old values destroyed automatically with "old_values_destroyer"
            //when "old_values_destroyer" goes out of scope unless the have trivial
            //destructor after move.
            if(value_traits::trivial_dctr_after_move)
               old_values_destroyer.release();
         }
         //s_before is so big that divides old_end
         else{
            //Old situation:
            // __________________________________________________
            //|            raw_mem         | old_begin | old_end |
            //| ___________________________|___________|_________|
            //
            //New situation:
            // __________________________________________________
            //| old_begin |   new    | old_end |  raw_mem        |
            //|___________|__________|_________|_________________|
            //
            //Now initialize the rest of memory with the last old values
            //All new elements correctly constructed, avoid new element destruction
            size_type raw_gap = s_before - (elemsbefore + n);
            //Now initialize the rest of s_before memory with the
            //first of elements after new values
            ::boost::container::uninitialized_move_alloc
               (this->alloc(), pos, pos + raw_gap, new_start + elemsbefore + n);
            //Update size since we have a contiguous buffer
            this->members_.m_size = old_size + s_before;
            //All new elements correctly constructed, avoid old element destruction
            old_values_destroyer.release();
            //Now copy remaining last objects in the old buffer begin
            T *to_destroy = ::boost::move(pos + raw_gap, old_finish, old_start);
            //Now destroy redundant elements except if they were moved and
            //they have trivial destructor after move
            size_type n_destroy =  old_finish - to_destroy;
            if(!value_traits::trivial_dctr_after_move)
               this->destroy_n(to_destroy, n_destroy);
            this->members_.m_size -= n_destroy;
         }
      }
      else{
         //Check if we have to do the insertion in two phases
         //since maybe s_before is not big enough and
         //the buffer was expanded both sides
         //
         //Old situation:
         // _________________________________________________
         //| raw_mem | old_begin + old_end |  raw_mem        |
         //|_________|_____________________|_________________|
         //
         //New situation with do_after:
         // _________________________________________________
         //|     old_begin + new + old_end     |  raw_mem    |
         //|___________________________________|_____________|
         //
         //New without do_after:
         // _________________________________________________
         //| old_begin + new + old_end  |  raw_mem           |
         //|____________________________|____________________|
         //
         bool do_after    = n > s_before;

         //Now we can have two situations: the raw_mem of the
         //beginning divides the old_begin, or the new elements:
         if (s_before <= elemsbefore) {
            //The raw memory divides the old_begin group:
            //
            //If we need two phase construction (do_after)
            //new group is divided in new = new_beg + new_end groups
            //In this phase only new_beg will be inserted
            //
            //Old situation:
            // _________________________________________________
            //| raw_mem | old_begin | old_end |  raw_mem        |
            //|_________|___________|_________|_________________|
            //
            //New situation with do_after(1):
            //This is not definitive situation, the second phase
            //will include
            // _________________________________________________
            //| old_begin | new_beg | old_end |  raw_mem        |
            //|___________|_________|_________|_________________|
            //
            //New situation without do_after:
            // _________________________________________________
            //| old_begin | new | old_end |  raw_mem            |
            //|___________|_____|_________|_____________________|
            //
            //Copy the first part of old_begin to raw_mem
            T *start_n = old_start + difference_type(s_before);
            ::boost::container::uninitialized_move_alloc
               (this->alloc(), old_start, start_n, new_start);
            //The buffer is all constructed until old_end,
            //release destroyer and update size
            old_values_destroyer.release();
            this->members_.m_size = old_size + s_before;
            //Now copy the second part of old_begin overwriting himself
            T* next = ::boost::move(start_n, pos, old_start);
            if(do_after){
               //Now copy the new_beg elements
               interf.copy_some_and_update(next, s_before, true);
            }
            else{
               //Now copy the all the new elements
               interf.copy_remaining_to(next);
               T* move_start = next + n;
               //Now displace old_end elements
               T* move_end   = ::boost::move(pos, old_finish, move_start);
               //Destroy remaining moved elements from old_end except if
               //they have trivial destructor after being moved
               difference_type n_destroy = s_before - n;
               if(!value_traits::trivial_dctr_after_move)
                  this->destroy_n(move_end, n_destroy);
               this->members_.m_size -= n_destroy;
            }
         }
         else {
            //If we have to expand both sides,
            //we will play if the first new values so
            //calculate the upper bound of new values

            //The raw memory divides the new elements
            //
            //If we need two phase construction (do_after)
            //new group is divided in new = new_beg + new_end groups
            //In this phase only new_beg will be inserted
            //
            //Old situation:
            // _______________________________________________________
            //|   raw_mem     | old_begin | old_end |  raw_mem        |
            //|_______________|___________|_________|_________________|
            //
            //New situation with do_after():
            // ____________________________________________________
            //| old_begin |    new_beg    | old_end |  raw_mem     |
            //|___________|_______________|_________|______________|
            //
            //New situation without do_after:
            // ______________________________________________________
            //| old_begin | new | old_end |  raw_mem                 |
            //|___________|_____|_________|__________________________|
            //
            //First copy whole old_begin and part of new to raw_mem
            ::boost::container::uninitialized_move_alloc
               (this->alloc(), old_start, pos, new_start);
            this->members_.m_size = elemsbefore;

            const size_type mid_n = difference_type(s_before) - elemsbefore;
            interf.uninitialized_copy_some_and_update(new_start + elemsbefore, mid_n, true);
            this->members_.m_size = old_size + s_before;
            //The buffer is all constructed until old_end,
            //release destroyer and update size
            old_values_destroyer.release();

            if(do_after){
               //Copy new_beg part
               interf.copy_some_and_update(old_start, s_before - mid_n, true);
            }
            else{
               //Copy all new elements
               interf.copy_remaining_to(old_start);
               T* move_start = old_start + (n-mid_n);
               //Displace old_end
               T* move_end = ::boost::move(pos, old_finish, move_start);
               //Destroy remaining moved elements from old_end except if they
               //have trivial destructor after being moved
               difference_type n_destroy = s_before - n;
               if(!value_traits::trivial_dctr_after_move)
                  this->destroy_n(move_end, n_destroy);
               this->members_.m_size -= n_destroy;
            }
         }

         //This is only executed if two phase construction is needed
         //This can be executed without exception handling since we
         //have to just copy and append in raw memory and
         //old_values_destroyer has been released in phase 1.
         if(do_after){
            //The raw memory divides the new elements
            //
            //Old situation:
            // ______________________________________________________
            //|   raw_mem    | old_begin |  old_end   |  raw_mem     |
            //|______________|___________|____________|______________|
            //
            //New situation with do_after(1):
            // _______________________________________________________
            //| old_begin   +   new_beg  | new_end |old_end | raw_mem |
            //|__________________________|_________|________|_________|
            //
            //New situation with do_after(2):
            // ______________________________________________________
            //| old_begin      +       new            | old_end |raw |
            //|_______________________________________|_________|____|
            //
            const size_type n_after  = n - s_before;
            const difference_type elemsafter = old_size - elemsbefore;

            //We can have two situations:
            if (elemsafter > difference_type(n_after)){
               //The raw_mem from end will divide displaced old_end
               //
               //Old situation:
               // ______________________________________________________
               //|   raw_mem    | old_begin |  old_end   |  raw_mem     |
               //|______________|___________|____________|______________|
               //
               //New situation with do_after(1):
               // _______________________________________________________
               //| old_begin   +   new_beg  | new_end |old_end | raw_mem |
               //|__________________________|_________|________|_________|
               //
               //First copy the part of old_end raw_mem
               T* finish_n = old_finish - difference_type(n_after);
               ::boost::container::uninitialized_move_alloc
                  (this->alloc(), finish_n, old_finish, old_finish);
               this->members_.m_size += n_after;
               //Displace the rest of old_end to the new position
               boost::move_backward(pos, finish_n, old_finish);
               //Now overwrite with new_end
               //The new_end part is [first + (n - n_after), last)
               interf.copy_remaining_to(pos);
            }
            else {
               //The raw_mem from end will divide new_end part
               //
               //Old situation:
               // _____________________________________________________________
               //|   raw_mem    | old_begin |  old_end   |  raw_mem            |
               //|______________|___________|____________|_____________________|
               //
               //New situation with do_after(2):
               // _____________________________________________________________
               //| old_begin   +   new_beg  |     new_end   |old_end | raw_mem |
               //|__________________________|_______________|________|_________|
               //
               size_type mid_last_dist = n_after - elemsafter;
               //First initialize data in raw memory
               //The new_end part is [first + (n - n_after), last)
               interf.uninitialized_copy_some_and_update(old_finish, elemsafter, false);
               this->members_.m_size += mid_last_dist;
               ::boost::container::uninitialized_move_alloc
                  (this->alloc(), pos, old_finish, old_finish + mid_last_dist);
               this->members_.m_size += n_after - mid_last_dist;
               //Now copy the part of new_end over constructed elements
               interf.copy_remaining_to(pos);
            }
         }
      }
   }

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq %rcx, 0x118(%rsp)
movq %r8, 0x110(%rsp)
movq %r9, 0x108(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rax), %rdi
callq 0x85b0
movq 0x20(%rsp), %rdi
movq %rax, 0x100(%rsp)
movq 0x100(%rsp), %rax
imulq $0x30, 0x8(%rdi), %rcx
addq %rcx, %rax
movq %rax, 0xf8(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0xf0(%rsp)
movq 0x118(%rsp), %rax
movq 0x100(%rsp), %rcx
subq %rcx, %rax
movl $0x30, %ecx
cqto
idivq %rcx
movq %rax, 0xe8(%rsp)
movq 0x100(%rsp), %rax
movq 0x128(%rsp), %rcx
subq %rcx, %rax
movl $0x30, %ecx
cqto
idivq %rcx
movq %rax, 0xe0(%rsp)
movq 0x128(%rsp), %rax
movq %rax, (%rdi)
movq 0x120(%rsp), %rax
movq %rax, 0x10(%rdi)
movq $0x0, 0x8(%rdi)
movq 0x100(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x85a0
movq 0x28(%rsp), %rsi
movq %rax, %rdx
movq 0xf0(%rsp), %rcx
leaq 0xc8(%rsp), %rdi
callq 0xadd0
movq 0xe0(%rsp), %rax
movq 0xe8(%rsp), %rcx
addq 0x110(%rsp), %rcx
cmpq %rcx, %rax
jl 0x9fe8
movq 0x20(%rsp), %rdi
callq 0x85a0
movq %rax, %rdi
movq 0x100(%rsp), %rsi
movq 0x118(%rsp), %rdx
movq 0x128(%rsp), %rcx
callq 0xab50
jmp 0x9d82
movq 0x20(%rsp), %rax
movq 0xe8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x108(%rsp), %rdi
movq 0x128(%rsp), %rsi
movq 0xe8(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x9dc1
movq 0x20(%rsp), %rax
movq 0x110(%rsp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0xe0(%rsp), %rax
movq 0xf0(%rsp), %rcx
addq 0x110(%rsp), %rcx
cmpq %rcx, %rax
jb 0x9e8d
movq 0x20(%rsp), %rdi
callq 0x85a0
movq %rax, %rdi
movq 0x118(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq 0x128(%rsp), %rcx
movq 0xe8(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq 0x110(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rcx
callq 0xab50
jmp 0x9e49
movq 0x20(%rsp), %rax
movq 0xf0(%rsp), %rcx
addq 0x110(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x9fe3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0xaef0
jmp 0xa4ff
movq 0x20(%rsp), %rdi
movq 0xe0(%rsp), %rax
movq 0xe8(%rsp), %rcx
movq 0x110(%rsp), %rdx
addq %rdx, %rcx
subq %rcx, %rax
movq %rax, 0xb0(%rsp)
callq 0x85a0
movq %rax, %rdi
movq 0x118(%rsp), %rsi
movq 0xb0(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq %rsi, %rdx
addq %rax, %rdx
movq 0x128(%rsp), %rcx
movq 0xe8(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq 0x110(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rcx
callq 0xab50
jmp 0x9f13
movq 0x20(%rsp), %rax
movq 0xf0(%rsp), %rcx
movq 0xe0(%rsp), %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0xc8(%rsp), %rdi
callq 0xae10
jmp 0x9f3e
movq 0x118(%rsp), %rdi
movq 0xb0(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0xf8(%rsp), %rsi
movq 0x100(%rsp), %rdx
callq 0xae30
movq %rax, 0x18(%rsp)
jmp 0x9f75
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xf8(%rsp), %rax
movq 0xa8(%rsp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movq %rax, 0xa0(%rsp)
movq 0xa8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0xae90
jmp 0x9fcb
movq 0x20(%rsp), %rax
movq 0xa0(%rsp), %rdx
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0xa4ea
movq 0x110(%rsp), %rax
cmpq 0xe0(%rsp), %rax
seta %al
andb $0x1, %al
movb %al, 0x9f(%rsp)
movq 0xe0(%rsp), %rax
cmpq 0xe8(%rsp), %rax
ja 0xa1af
movq 0x20(%rsp), %rdi
movq 0x100(%rsp), %rax
movq 0xe0(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x90(%rsp)
callq 0x85a0
movq %rax, %rdi
movq 0x100(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq 0x128(%rsp), %rcx
callq 0xab50
jmp 0xa069
leaq 0xc8(%rsp), %rdi
callq 0xae10
jmp 0xa078
movq 0x20(%rsp), %rax
movq 0xf0(%rsp), %rcx
movq 0xe0(%rsp), %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x90(%rsp), %rdi
movq 0x118(%rsp), %rsi
movq 0x100(%rsp), %rdx
callq 0xae30
movq %rax, 0x10(%rsp)
jmp 0xa0b8
movq 0x10(%rsp), %rax
movq %rax, 0x88(%rsp)
testb $0x1, 0x9f(%rsp)
je 0xa0fc
movq 0x108(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0xe0(%rsp), %rdx
movq (%rdi), %rax
movq 0x18(%rax), %rax
movl $0x1, %ecx
callq *%rax
jmp 0xa0f7
jmp 0xa1aa
movq 0x108(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0xa116
movq 0x88(%rsp), %rax
movq 0x110(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x80(%rsp)
movq 0x118(%rsp), %rdi
movq 0xf8(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0xae30
movq %rax, 0x8(%rsp)
jmp 0xa15d
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xe0(%rsp), %rax
movq 0x110(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0xae90
jmp 0xa195
movq 0x20(%rsp), %rax
movq 0x70(%rsp), %rdx
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0xa356
movq 0x20(%rsp), %rdi
callq 0x85a0
movq %rax, %rdi
movq 0x100(%rsp), %rsi
movq 0x118(%rsp), %rdx
movq 0x128(%rsp), %rcx
callq 0xab50
jmp 0xa1db
movq 0x20(%rsp), %rax
movq 0xe8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xe0(%rsp), %rax
movq 0xe8(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x68(%rsp)
movq 0x108(%rsp), %rdi
movq 0x128(%rsp), %rsi
movq 0xe8(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq 0x68(%rsp), %rdx
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl $0x1, %ecx
callq *%rax
jmp 0xa23c
movq 0x20(%rsp), %rax
movq 0xf0(%rsp), %rcx
movq 0xe0(%rsp), %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq 0xc8(%rsp), %rdi
callq 0xae10
jmp 0xa267
testb $0x1, 0x9f(%rsp)
je 0xa2a6
movq 0x108(%rsp), %rdi
movq 0x100(%rsp), %rsi
movq 0xe0(%rsp), %rdx
movq 0x68(%rsp), %rax
subq %rax, %rdx
movq (%rdi), %rax
movq 0x18(%rax), %rax
movl $0x1, %ecx
callq *%rax
jmp 0xa2a1
jmp 0xa354
movq 0x108(%rsp), %rdi
movq 0x100(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0xa2c0
movq 0x100(%rsp), %rax
movq 0x110(%rsp), %rcx
movq 0x68(%rsp), %rdx
subq %rdx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x60(%rsp)
movq 0x118(%rsp), %rdi
movq 0xf8(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0xae30
movq %rax, (%rsp)
jmp 0xa308
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0xe0(%rsp), %rax
movq 0x110(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0xae90
jmp 0xa33f
movq 0x20(%rsp), %rax
movq 0x50(%rsp), %rdx
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0xa356
testb $0x1, 0x9f(%rsp)
je 0xa4e8
movq 0x110(%rsp), %rax
subq 0xe0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xf0(%rsp), %rax
subq 0xe8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jle 0xa432
movq 0x20(%rsp), %rdi
movq 0xf8(%rsp), %rax
movq 0x48(%rsp), %rcx
negq %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
callq 0x85a0
movq %rax, %rdi
movq 0x38(%rsp), %rsi
movq 0xf8(%rsp), %rcx
movq %rcx, %rdx
callq 0xab50
jmp 0xa3e2
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rdx
movq 0x8(%rax), %rcx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x118(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0xf8(%rsp), %rdx
callq 0xabe0
jmp 0xa413
movq 0x108(%rsp), %rdi
movq 0x118(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0xa42d
jmp 0xa4e6
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x108(%rsp), %rdi
movq 0xf8(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq (%rdi), %rax
movq 0x10(%rax), %rax
xorl %ecx, %ecx
callq *%rax
jmp 0xa466
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rcx
movq 0x8(%rdi), %rax
addq %rcx, %rax
movq %rax, 0x8(%rdi)
callq 0x85a0
movq %rax, %rdi
movq 0x118(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq 0x30(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq %rdx, %rcx
addq %rax, %rcx
callq 0xab50
jmp 0xa4ad
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rdx
movq 0x30(%rsp), %rcx
subq %rcx, %rdx
movq 0x8(%rax), %rcx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x108(%rsp), %rdi
movq 0x118(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0xa4e4
jmp 0xa4e6
jmp 0xa4e8
jmp 0xa4ea
leaq 0xc8(%rsp), %rdi
callq 0xaef0
addq $0x138, %rsp            # imm = 0x138
retq
movq 0xc0(%rsp), %rdi
callq 0x33e0
nopl (%rax)