LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/stack.h
// Function: rapidjson::internal::Stack<rapidjson::CrtAllocator>::ShrinkToFit()
void ShrinkToFit() { 
        if (Empty()) {
            // If the stack is empty, completely deallocate the memory.
            Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc)
            stack_ = 0;
            stackTop_ = 0;
            stackEnd_ = 0;
        }
        else
            Resize(GetSize());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xea90
testb $0x1, %al
jne 0x1d2ff
jmp 0x1d32a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xe680
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
jmp 0x1d33f
movq -0x10(%rbp), %rdi
callq 0xeee0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0xf230
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericMemberIterator<false, rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::FindMember<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&)
MemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) {
        RAPIDJSON_ASSERT(IsObject());
        RAPIDJSON_ASSERT(name.IsString());
        MemberIterator member = MemberBegin();
        for ( ; member != MemberEnd(); ++member)
            if (name.StringEqual(member->name))
                break;
        return member;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xe660
testb $0x1, %al
jne 0x1d4f2
jmp 0x1d4f4
jmp 0x1d513
leaq 0x1293(%rip), %rdi      # 0x1e78e
leaq 0xd7c(%rip), %rsi       # 0x1e27e
movl $0x505, %edx            # imm = 0x505
leaq 0x35cd(%rip), %rcx      # 0x20adb
callq 0xe600
movq -0x18(%rbp), %rdi
callq 0xe1d0
testb $0x1, %al
jne 0x1d522
jmp 0x1d524
jmp 0x1d543
leaq 0xd43(%rip), %rdi       # 0x1e26e
leaq 0xd4c(%rip), %rsi       # 0x1e27e
movl $0x506, %edx            # imm = 0x506
leaq 0x359d(%rip), %rcx      # 0x20adb
callq 0xe600
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0xe6c0
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xe760
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe400
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf270
testb $0x1, %al
jne 0x1d57d
jmp 0x1d5af
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0xe470
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xf350
testb $0x1, %al
jne 0x1d5a0
jmp 0x1d5a2
jmp 0x1d5af
jmp 0x1d5a4
movq -0x40(%rbp), %rdi
callq 0xee80
jmp 0x1d550
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: bool rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::StringEqual<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&) const
bool StringEqual(const GenericValue<Encoding, SourceAllocator>& rhs) const {
        RAPIDJSON_ASSERT(IsString());
        RAPIDJSON_ASSERT(rhs.IsString());

        const SizeType len1 = GetStringLength();
        const SizeType len2 = rhs.GetStringLength();
        if(len1 != len2) { return false; }

        const Ch* const str1 = GetString();
        const Ch* const str2 = rhs.GetString();
        if(str1 == str2) { return true; } // fast path for constant string

        return (std::memcmp(str1, str2, sizeof(Ch) * len1) == 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xe1d0
testb $0x1, %al
jne 0x1d6f3
jmp 0x1d6f5
jmp 0x1d714
leaq 0xb77(%rip), %rdi       # 0x1e273
leaq 0xb7b(%rip), %rsi       # 0x1e27e
movl $0x84a, %edx            # imm = 0x84A
leaq 0x35ee(%rip), %rcx      # 0x20cfd
callq 0xe600
movq -0x18(%rbp), %rdi
callq 0xe1d0
testb $0x1, %al
jne 0x1d723
jmp 0x1d725
jmp 0x1d744
leaq 0x36c6(%rip), %rdi      # 0x20df2
leaq 0xb4b(%rip), %rsi       # 0x1e27e
movl $0x84b, %edx            # imm = 0x84B
leaq 0x35be(%rip), %rcx      # 0x20cfd
callq 0xe600
movq -0x38(%rbp), %rdi
callq 0xea80
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xea80
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x1d76a
movb $0x0, -0x1(%rbp)
jmp 0x1d7b5
movq -0x38(%rbp), %rdi
callq 0xe170
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe170
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x1d794
movb $0x1, -0x1(%rbp)
jmp 0x1d7b5
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
shlq $0x0, %rdx
callq 0xe3c0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>& rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator[]<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&)
GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) {
        MemberIterator member = FindMember(name);
        if (member != MemberEnd())
            return member->value;
        else {
            RAPIDJSON_ASSERT(false);    // see above note

            // This will generate -Wexit-time-destructors in clang
            // static GenericValue NullValue;
            // return NullValue;

            // Use static buffer and placement-new to prevent destruction
            static char buffer[sizeof(GenericValue)];
            return *new (buffer) GenericValue();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xe6b0
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xe760
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe400
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xf270
testb $0x1, %al
jne 0x1d872
jmp 0x1d885
leaq -0x18(%rbp), %rdi
callq 0xe470
addq $0x10, %rax
addq $0x30, %rsp
popq %rbp
retq
leaq 0x9d9(%rip), %rdi       # 0x1e265
leaq 0x9eb(%rip), %rsi       # 0x1e27e
movl $0x491, %edx            # imm = 0x491
leaq 0x3562(%rip), %rcx      # 0x20e01
callq 0xe600
nopw %cs:(%rax,%rax)
nop
// File: willprice[P]parallel-cpp-workshop/parallel_reduce.cpp
// Function: main
int main(int argc, char **argv)
{
  auto total = tbb::parallel_reduce(
      tbb::blocked_range<int>(0, 10000),
      0.0,
      [&](tbb::blocked_range<int> r, double running_total) {
        for (int i = r.begin(); i < r.end(); i++) {
          running_total += std::sin(i * 0.001);
        }
        return running_total;
      }, std::plus<double>());
  std::cout << total << std::endl;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x2710, %edx           # imm = 0x2710
movl $0x1, %ecx
callq 0x3770
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rdx
leaq 0x6(%rsp), %rcx
callq 0x2340
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movq 0x5cc0(%rip), %rdi      # 0x7fd8
callq 0x2170
movq %rax, %rdi
movq 0x5ca1(%rip), %rsi      # 0x7fc8
callq 0x20d0
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH07_Classes/examples/useAccount.cc
// Function: main
int main()
{
	Account a1("bem", 42);
	cout << a1.balance() << endl;
	a1.calculate();
	cout << a1.balance() << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movl $0x0, -0x4(%rbp)
leaq -0x141(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0x10a0
movq -0x160(%rbp), %rdx
leaq 0xd15(%rip), %rsi       # 0x2028
leaq -0x140(%rbp), %rdi
callq 0x1070
jmp 0x1321
leaq -0x120(%rbp), %rdi
leaq -0x140(%rbp), %rsi
movsd 0xce9(%rip), %xmm0      # 0x2020
callq 0x1480
jmp 0x133e
leaq -0x140(%rbp), %rdi
callq 0x10c8
leaq -0x141(%rbp), %rdi
callq 0x1060
leaq -0x120(%rbp), %rdi
callq 0x14c0
movsd %xmm0, -0x168(%rbp)
jmp 0x136c
movsd -0x168(%rbp), %xmm0
movq 0x2c5d(%rip), %rdi      # 0x3fd8
callq 0x10b0
movq %rax, -0x170(%rbp)
jmp 0x1389
movq -0x170(%rbp), %rdi
movq 0x2c29(%rip), %rsi      # 0x3fc0
callq 0x1050
jmp 0x139e
leaq -0x120(%rbp), %rdi
callq 0x14e0
jmp 0x13ac
leaq -0x120(%rbp), %rdi
callq 0x14c0
movsd %xmm0, -0x178(%rbp)
jmp 0x13c2
movsd -0x178(%rbp), %xmm0
movq 0x2c07(%rip), %rdi      # 0x3fd8
callq 0x10b0
movq %rax, -0x180(%rbp)
jmp 0x13df
movq -0x180(%rbp), %rdi
movq 0x2bd3(%rip), %rsi      # 0x3fc0
callq 0x1050
jmp 0x13f4
movl $0x0, -0x4(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x1510
movl -0x4(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x150(%rbp)
movl %eax, -0x154(%rbp)
jmp 0x1445
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x150(%rbp)
movl %eax, -0x154(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x10c8
leaq -0x141(%rbp), %rdi
callq 0x1060
jmp 0x1471
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x150(%rbp)
movl %eax, -0x154(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x1510
movq -0x150(%rbp), %rdi
callq 0x1090
nopl (%rax)
// File: Eshaancoding[P]AutoDiff/src/Matrix/Mat.cpp
// Function: Matrix::Matrix(int, int)
Matrix::Matrix (int height, int width) {
    this->width = width;
    this->height = height;
    array = new Vector[height];
    for (int i = 0; i < height; i++) {
        array[i] = Vector(width);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movslq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x10, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2aee
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rdx
shlq $0x4, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb320
jmp 0x2ad9
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
addq $0x10, %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x2aca
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2b55
movl -0x10(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0xb250
movq -0x48(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movl -0x28(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2b00
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21f0
jmp 0x2b5b
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Matrix/Mat.cpp
// Function: Matrix::print()
void Matrix::print () {
    cout<<endl;
    for (int i = 0; i < this->height; i++) {
        for (int x = 0; x < this->width; x++) {
            cout<<this->array[i].array[x].value<<" ";
        }
        cout<<endl;
    }
    cout<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x1243d(%rip), %rdi     # 0x14fc8
movq 0x12426(%rip), %rsi     # 0x14fb8
callq 0x21d0
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2c28
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x2c07
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq 0x123e0(%rip), %rdi     # 0x14fc8
callq 0x22d0
movq %rax, %rdi
leaq 0xc611(%rip), %rsi      # 0xf208
callq 0x21b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2bb1
movq 0x123ba(%rip), %rdi     # 0x14fc8
movq 0x123a3(%rip), %rsi     # 0x14fb8
callq 0x21d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2b9e
movq 0x12399(%rip), %rdi     # 0x14fc8
movq 0x12382(%rip), %rsi     # 0x14fb8
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Matrix/operations.cpp
// Function: operator+(Matrix const&, Matrix const&)
Matrix operator+ (const Matrix &a, const Matrix &b) {
    // see if width / height is feasible
    if (a.width != b.width) throw invalid_argument("Width invalid");
    if (a.height != b.height) throw invalid_argument("Height invalid");
    // create matrix 
    Matrix return_mat = Matrix(a.height, a.width);
    // operations
    for (int i = 0; i < a.height; i++) {
        for (int x = 0; x < a.width; x++) {
            return_mat.array[i].array[x] = a.array[i].array[x] + b.array[i].array[x];
        }
    }
    // return
    return return_mat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0xc(%rcx), %eax
je 0x3446
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0xbc5b(%rip), %rsi      # 0xf069
callq 0x22c0
jmp 0x3415
movq -0x70(%rbp), %rdi
movq 0x11bc0(%rip), %rsi     # 0x14fe0
movq 0x11ba9(%rip), %rdx     # 0x14fd0
callq 0x2240
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2150
jmp 0x3591
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x34a9
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
leaq 0xbc06(%rip), %rsi      # 0xf077
callq 0x22c0
jmp 0x3478
movq -0x78(%rbp), %rdi
movq 0x11b5d(%rip), %rsi     # 0x14fe0
movq 0x11b46(%rip), %rdx     # 0x14fd0
callq 0x2240
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2150
jmp 0x3591
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edx
leaq -0x10(%rbp), %rdi
callq 0x2a50
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3580
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x3570
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movslq -0x34(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movslq -0x34(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdx
leaq -0x68(%rbp), %rdi
callq 0x7fa0
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movslq -0x34(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x68(%rbp), %rsi
movl $0x30, %edx
callq 0x2170
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x34de
jmp 0x3572
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x34c7
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2280
nopw (%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Matrix/operations.cpp
// Function: operator+(Matrix const&, double const&)
Matrix operator+ (const Matrix &a, const double &b) {
    // create matrix 
    Matrix return_mat = Matrix(a.height, a.width);
    // operations
    for (int i = 0; i < a.height; i++) {
        for (int x = 0; x < a.width; x++) {
            Variable *new_var = new Variable();
            new_var->operation = op::argument;
            new_var->value = b;
            return_mat.array[i].array[x] = a.array[i].array[x] + (*new_var);
        }
    }
    // return
    return return_mat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edx
leaq -0x10(%rbp), %rdi
callq 0x2a50
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x36cb
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x36bb
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x361b
movq -0x78(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movslq -0x28(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movq -0x30(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x7fa0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movslq -0x28(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x70(%rbp), %rsi
movl $0x30, %edx
callq 0x2170
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x35e8
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x21a0
jmp 0x36dc
jmp 0x36bd
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x35d1
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Matrix/operations.cpp
// Function: operator+(double const&, Matrix const&)
Matrix operator+ (const double &b, const Matrix &a) {
    // create matrix 
    Matrix return_mat = Matrix(a.height, a.width);
    // operations
    for (int i = 0; i < a.height; i++) {
        for (int x = 0; x < a.width; x++) {
            Variable *new_var = new Variable();
            new_var->operation = op::argument;
            new_var->value = b;
            return_mat.array[i].array[x] = *(new_var) + a.array[i].array[x];
        }
    }
    // return
    return return_mat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edx
leaq -0x10(%rbp), %rdi
callq 0x2a50
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x381b
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x380b
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x376b
movq -0x78(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movslq -0x28(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdx
leaq -0x70(%rbp), %rdi
callq 0x7fa0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movslq -0x28(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x70(%rbp), %rsi
movl $0x30, %edx
callq 0x2170
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3738
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x21a0
jmp 0x382c
jmp 0x380d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3721
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/Var.cpp
// Function: Variable::Variable(double, bool)
Variable::Variable (double value, bool t) {
    this->child[0] = nullptr;
    this->child[1] = nullptr;
    this->arg = nullptr;
    this->operation = op::input; 
    this->value = value;
    static int id_counter = 0;
    if (t) {
        id_counter++;
        this->id = id_counter;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x28(%rax)
movl $0x0, 0x8(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rax)
testb $0x1, -0x11(%rbp)
je 0x4ace
movq -0x20(%rbp), %rax
movl 0x106f0(%rip), %ecx     # 0x151ac
addl $0x1, %ecx
movl %ecx, 0x106e7(%rip)     # 0x151ac
movl 0x106e1(%rip), %ecx     # 0x151ac
movl %ecx, 0x20(%rax)
popq %rbp
retq
// File: Eshaancoding[P]AutoDiff/src/Variable/grad.cpp
// Function: print_array(std::vector<double, std::allocator<double>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void print_array (vector<double> array, string name = "") {
    if (name != "") {
        cout<<name<<": ";
    }
    for (auto a : array) {
        cout<<a<<" ";
    }
    cout<<endl; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x932f(%rip), %rsi      # 0xf209
callq 0x6a70
testb $0x1, %al
jne 0x5ee5
jmp 0x5f04
movq -0x38(%rbp), %rsi
movq 0xf0d8(%rip), %rdi      # 0x14fc8
callq 0x2190
movq %rax, %rdi
leaq 0x9308(%rip), %rsi      # 0xf207
callq 0x21b0
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6aa0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6ad0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6b00
testb $0x1, %al
jne 0x5f39
jmp 0x5f76
leaq -0x20(%rbp), %rdi
callq 0x6b40
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq 0xf071(%rip), %rdi      # 0x14fc8
callq 0x22d0
movq %rax, %rdi
leaq 0x92a2(%rip), %rsi      # 0xf208
callq 0x21b0
leaq -0x20(%rbp), %rdi
callq 0x6b60
jmp 0x5f26
movq 0xf04b(%rip), %rdi      # 0x14fc8
movq 0xf034(%rip), %rsi      # 0x14fb8
callq 0x21d0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable const&, Variable const&)
Variable operator+ (const Variable &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = new Variable();
    new_var.child[1] = new Variable();
    *(new_var.child[0]) = left;
    *(new_var.child[1]) = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %esi
movl %esi, -0x2c(%rbp)
callq 0x4a60
movq -0x40(%rbp), %rdi
movl $0x2, 0x8(%rdi)
movl $0x30, %edi
callq 0x21c0
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4a60
jmp 0x7c7e
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x7cad
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rsi
movq 0x10(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
jmp 0x7d17
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2280
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable const&, Variable&)
Variable operator+ (const Variable &left, Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = new Variable();
    *(new_var.child[0]) = left;
    new_var.child[1] = &right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %esi
movl %esi, -0x2c(%rbp)
callq 0x4a60
movq -0x40(%rbp), %rdi
movl $0x2, 0x8(%rdi)
movl $0x30, %edi
callq 0x21c0
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4a60
jmp 0x7d7e
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rsi
movq 0x10(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdx
movq %rdx, 0x18(%rcx)
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2280
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable const&, double const&)
Variable operator+ (const Variable &left, const double &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = new Variable();
    *(new_var.child[0]) = left;
    
    new_var.child[1] = new Variable(false);
    new_var.child[1]->value = right;
    new_var.child[1]->operation = op::argument;    
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %esi
movl %esi, -0x2c(%rbp)
callq 0x4a60
movq -0x40(%rbp), %rdi
movl $0x2, 0x8(%rdi)
movl $0x30, %edi
callq 0x21c0
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4a60
jmp 0x7e2e
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq 0x10(%rax), %rax
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x7e7b
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x50(%rbp), %rdx
movq %rdx, 0x18(%rcx)
movq -0x10(%rbp), %rdx
movsd (%rdx), %xmm0
movq 0x18(%rcx), %rdx
movsd %xmm0, (%rdx)
movq 0x18(%rcx), %rcx
movl $0x1, 0x8(%rcx)
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
jmp 0x7ed8
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable&, Variable const&)
Variable operator+ (Variable &left, const Variable &right) {
    Variable new_var = Variable(false); 
    new_var.operation = op::add;
    new_var.child[0] = &left;
    new_var.child[1] = new Variable();
    *(new_var.child[1]) = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %esi
movl %esi, -0x2c(%rbp)
callq 0x4a60
movq -0x40(%rbp), %rdi
movl $0x2, 0x8(%rdi)
movq -0x8(%rbp), %rax
movq %rax, 0x10(%rdi)
movl $0x30, %edi
callq 0x21c0
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4a60
jmp 0x7f56
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rsi
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2280
nopl (%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable&, Variable&)
Variable operator+ (Variable &left, Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = &left; 
    new_var.child[1] = &right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x2, 0x8(%rdi)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable&, double const&)
Variable operator+ (Variable &left, const double &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = &left;
    new_var.child[1] = new Variable(false);
    new_var.child[1]->value = right;
    new_var.child[1]->operation = op::argument;
    
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %esi
movl %esi, -0x2c(%rbp)
callq 0x4a60
movq -0x40(%rbp), %rdi
movl $0x2, 0x8(%rdi)
movq -0x8(%rbp), %rax
movq %rax, 0x10(%rdi)
movl $0x30, %edi
callq 0x21c0
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4a60
jmp 0x8056
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x18(%rcx)
movq -0x10(%rbp), %rdx
movsd (%rdx), %xmm0
movq 0x18(%rcx), %rdx
movsd %xmm0, (%rdx)
movq 0x18(%rcx), %rcx
movl $0x1, 0x8(%rcx)
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(double const&, Variable const&)
Variable operator+ (const double &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = new Variable(false);
    new_var.child[0]->value = left;
    new_var.child[0]->operation = op::argument;
    new_var.child[1] = new Variable();
    *(new_var.child[1]) = right; 
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %esi
movl %esi, -0x2c(%rbp)
callq 0x4a60
movq -0x40(%rbp), %rdi
movl $0x2, 0x8(%rdi)
movl $0x30, %edi
callq 0x21c0
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4a60
jmp 0x810e
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movsd (%rcx), %xmm0
movq 0x10(%rax), %rcx
movsd %xmm0, (%rcx)
movq 0x10(%rax), %rax
movl $0x1, 0x8(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x8158
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rsi
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
jmp 0x81ac
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(double const&, Variable&)
Variable operator+ (const double &left, Variable &right) {
    Variable new_var = Variable(false); 
    new_var.operation = op::add; 
    new_var.child[0] = new Variable(false);
    new_var.child[0]->operation = op::argument;
    new_var.child[0]->value = left;
    new_var.child[1] = &right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %esi
movl %esi, -0x2c(%rbp)
callq 0x4a60
movq -0x40(%rbp), %rdi
movl $0x2, 0x8(%rdi)
movl $0x30, %edi
callq 0x21c0
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4a60
jmp 0x821e
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x10(%rcx)
movq 0x10(%rcx), %rdx
movl $0x1, 0x8(%rdx)
movq -0x8(%rbp), %rdx
movsd (%rdx), %xmm0
movq 0x10(%rcx), %rdx
movsd %xmm0, (%rdx)
movq -0x10(%rbp), %rdx
movq %rdx, 0x18(%rcx)
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
nop
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable const&, Variable const&)
Variable Variable::clip (const Variable &left, const Variable &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = new Variable();
    *(new_var.child[0]) = left;
    new_var.child[1] = new Variable();
    *(new_var.child[1]) = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x1, %esi
movl %esi, -0x34(%rbp)
callq 0x4a60
movl $0x30, %edi
callq 0x21c0
movsd -0x40(%rbp), %xmm0
movl -0x34(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x4a60
jmp 0x82df
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rdx, 0x28(%rax)
movsd (%rcx), %xmm0
movq 0x28(%rax), %rcx
movsd %xmm0, (%rcx)
movl $0xa, 0x8(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x8325
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rax), %rax
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x8372
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rsi
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x83dd
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x83dd
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
movq -0x20(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable const&, Variable&)
Variable Variable::clip (const Variable &left, Variable &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = new Variable(); 
    *(new_var.child[0]) = left;
    new_var.child[1] = &right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x1, %esi
movl %esi, -0x34(%rbp)
callq 0x4a60
movl $0x30, %edi
callq 0x21c0
movsd -0x40(%rbp), %xmm0
movl -0x34(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x4a60
jmp 0x844f
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rdx, 0x28(%rax)
movsd (%rcx), %xmm0
movq 0x28(%rax), %rcx
movsd %xmm0, (%rcx)
movl $0xa, 0x8(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x8495
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rsi
movq 0x10(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rdx
movq %rdx, 0x18(%rcx)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x84f5
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
movq -0x20(%rbp), %rdi
callq 0x2280
nop
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable const&, double const&)
Variable Variable::clip (const Variable &left, const double &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = new Variable();
    *(new_var.child[0]) = left;
    new_var.child[1] = new Variable();
    new_var.child[1]->operation = op::argument;
    new_var.child[1]->value = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x1, %esi
movl %esi, -0x34(%rbp)
callq 0x4a60
movl $0x30, %edi
callq 0x21c0
movsd -0x40(%rbp), %xmm0
movl -0x34(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x4a60
jmp 0x855f
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rdx, 0x28(%rax)
movsd (%rcx), %xmm0
movq 0x28(%rax), %rcx
movsd %xmm0, (%rcx)
movl $0xa, 0x8(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x85a5
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rax), %rax
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x85f2
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq -0x68(%rbp), %rdx
movq %rdx, 0x18(%rcx)
movq 0x18(%rcx), %rdx
movl $0x1, 0x8(%rdx)
movq -0x18(%rbp), %rdx
movsd (%rdx), %xmm0
movq 0x18(%rcx), %rcx
movsd %xmm0, (%rcx)
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x8666
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x8666
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
movq -0x20(%rbp), %rdi
callq 0x2280
nop
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable&, Variable const&)
Variable Variable::clip (Variable &left, const Variable &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = &left;
    new_var.child[1] = new Variable(); 
    *(new_var.child[1]) = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x1, %esi
movl %esi, -0x34(%rbp)
callq 0x4a60
movl $0x30, %edi
callq 0x21c0
movsd -0x40(%rbp), %xmm0
movl -0x34(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x4a60
jmp 0x86cf
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rdx, 0x28(%rax)
movsd (%rcx), %xmm0
movq 0x28(%rax), %rcx
movsd %xmm0, (%rcx)
movl $0xa, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x871d
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rsi
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x8771
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
movq -0x20(%rbp), %rdi
callq 0x2280
nopw (%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable&, Variable&)
Variable Variable::clip (Variable &left, Variable &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = &left;
    new_var.child[1] = &right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x1, %esi
movl %esi, -0x34(%rbp)
callq 0x4a60
movl $0x30, %edi
callq 0x21c0
movsd -0x40(%rbp), %xmm0
movl -0x34(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x4a60
jmp 0x87df
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rsi
movq %rsi, 0x28(%rcx)
movsd (%rdx), %xmm0
movq 0x28(%rcx), %rdx
movsd %xmm0, (%rdx)
movl $0xa, 0x8(%rcx)
movq -0x10(%rbp), %rdx
movq %rdx, 0x10(%rcx)
movq -0x18(%rbp), %rdx
movq %rdx, 0x18(%rcx)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
movq -0x20(%rbp), %rdi
callq 0x2280
nopw (%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable&, double const&)
Variable Variable::clip (Variable &left, const double &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = &left;
    new_var.child[1] = new Variable();
    new_var.child[1]->operation = op::argument;
    new_var.child[1]->value = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x1, %esi
movl %esi, -0x34(%rbp)
callq 0x4a60
movl $0x30, %edi
callq 0x21c0
movsd -0x40(%rbp), %xmm0
movl -0x34(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x4a60
jmp 0x889f
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rdx, 0x28(%rax)
movsd (%rcx), %xmm0
movq 0x28(%rax), %rcx
movsd %xmm0, (%rcx)
movl $0xa, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x88ed
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rdx
movq %rdx, 0x18(%rcx)
movq 0x18(%rcx), %rdx
movl $0x1, 0x8(%rdx)
movq -0x18(%rbp), %rdx
movsd (%rdx), %xmm0
movq 0x18(%rcx), %rcx
movsd %xmm0, (%rcx)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x894a
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
movq -0x20(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(double const&, Variable const&)
Variable Variable::clip (const double &left, const Variable &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = new Variable();
    new_var.child[0]->value = left;
    new_var.child[0]->operation = op::argument;
    new_var.child[1] = new Variable();
    *(new_var.child[1]) = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x1, %esi
movl %esi, -0x34(%rbp)
callq 0x4a60
movl $0x30, %edi
callq 0x21c0
movsd -0x40(%rbp), %xmm0
movl -0x34(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x4a60
jmp 0x89bf
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rdx, 0x28(%rax)
movsd (%rcx), %xmm0
movq 0x28(%rax), %rcx
movsd %xmm0, (%rcx)
movl $0xa, 0x8(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x8a05
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movq 0x10(%rax), %rcx
movsd %xmm0, (%rcx)
movq 0x10(%rax), %rax
movl $0x1, 0x8(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x8a4f
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rsi
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x8aba
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x8aba
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
movq -0x20(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)