LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/utils/ParallelOperator.h
// Function: abcdl::utils::ParallelOperator<int>::parallel_mul2one(int*, unsigned long, std::function<void (int*)> const&) const
void parallel_mul2one(T* op1,
                          const size_t num_op1,
                          const std::function<void(T*)> &f) const{
        size_t block_size = get_block_size(num_op1);
        size_t num_thread = get_num_thread(num_op1, block_size);
        std::vector<std::thread> threads(num_thread);

        for(size_t i = 0; i != num_thread; i++){
            threads[i] = std::thread(
                [&op1, &f](size_t start_idx, size_t end_idx){
                    for(size_t ti = start_idx; ti != end_idx; ti++){
                        f(&op1[ti]);
                    }
                }, i * block_size, std::min(num_op1, (i + 1) * block_size)
            );
        }

        for(auto& thread : threads){
            thread.join();
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %rcx
movq %rsi, 0x50(%rsp)
movq %rdx, 0x8(%rsp)
movq (%rdi), %r14
movq 0x8(%rdi), %rsi
movq %rdx, %rax
xorl %edx, %edx
divq %r14
cmpq $0x1, %rdx
sbbq $-0x1, %rax
cmpq %rcx, %rsi
movq %rcx, %rbp
cmovbq %rsi, %rbp
cmpq %rsi, %rax
cmovaeq %rax, %rbp
cmpq %rbp, %rsi
jb 0xa32c
movq %rcx, %rax
xorl %edx, %edx
divq %rbp
movq %rax, %r14
cmpq $0x1, %rdx
sbbq $-0x1, %r14
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq 0xa43e
testq %r14, %r14
je 0xa3aa
xorl %r15d, %r15d
leaq 0x18(%rsp), %r13
xorl %r12d, %r12d
leaq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
movq %r15, 0x18(%rsp)
addq %rbp, %r15
movq %r15, 0x10(%rsp)
leaq 0x10(%rsp), %rcx
cmpq 0x8(%rsp), %r15
jb 0xa37b
leaq 0x8(%rsp), %rcx
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r13, %rdx
callq 0xa4ac
movq 0x38(%rsp), %rax
cmpq $0x0, (%rax,%r12,8)
jne 0xa3e0
movq 0x30(%rsp), %rcx
movq %rcx, (%rax,%r12,8)
incq %r12
cmpq %r12, %r14
jne 0xa34e
movq 0x38(%rsp), %rbx
movq 0x40(%rsp), %r14
cmpq %r14, %rbx
je 0xa3c7
movq %rbx, %rdi
callq 0x95a0
addq $0x8, %rbx
jmp 0xa3b4
leaq 0x38(%rsp), %rdi
callq 0xa536
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90c0
jmp 0xa3e7
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xa536
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/utils/ParallelOperator.h
// Function: abcdl::utils::ParallelOperator<int>::parallel_mul2one(int*, unsigned long, int const&, std::function<void (int*, int const&)> const&) const
void parallel_mul2one(T* op1,
                          const size_t num_op1,
                          const T& op2,
                          const std::function<void(T*, const T&)> &f) const{
        size_t block_size = get_block_size(num_op1);
        size_t num_thread = get_num_thread(num_op1, block_size);
        std::vector<std::thread> threads(num_thread);

        for(size_t i = 0; i != num_thread; i++){
            threads[i] = std::thread(
                [&op1, &op2, &f](size_t start_idx, size_t end_idx){
                    for(size_t ti = start_idx; ti != end_idx; ti++){
                        f(&op1[ti], op2);
                    }
                }, i * block_size, std::min(num_op1, (i + 1) * block_size)
            );
        }

        for(auto& thread : threads){
            thread.join();
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %rcx
movq %rsi, 0x38(%rsp)
movq %rdx, (%rsp)
movq (%rdi), %r15
movq 0x8(%rdi), %rsi
movq %rdx, %rax
xorl %edx, %edx
divq %r15
cmpq $0x1, %rdx
sbbq $-0x1, %rax
cmpq %rcx, %rsi
movq %rcx, %r12
cmovbq %rsi, %r12
cmpq %rsi, %rax
cmovaeq %rax, %r12
cmpq %r12, %rsi
jb 0xa5ca
movq %rcx, %rax
xorl %edx, %edx
divq %r12
movq %rax, %r15
cmpq $0x1, %rdx
sbbq $-0x1, %r15
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %r15, %rsi
callq 0xa43e
testq %r15, %r15
je 0xa646
xorl %r13d, %r13d
xorl %ebp, %ebp
leaq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %r14, 0x48(%rsp)
movq %rbx, 0x50(%rsp)
movq %r13, 0x10(%rsp)
addq %r12, %r13
movq %r13, 0x8(%rsp)
leaq 0x8(%rsp), %rcx
cmpq (%rsp), %r13
jb 0xa615
movq %rsp, %rcx
leaq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0xa698
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax,%rbp,8)
jne 0xa67c
movq 0x18(%rsp), %rcx
movq %rcx, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r15
jne 0xa5e6
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %r14
cmpq %r14, %rbx
je 0xa663
movq %rbx, %rdi
callq 0x95a0
addq $0x8, %rbx
jmp 0xa650
leaq 0x20(%rsp), %rdi
callq 0xa536
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90c0
jmp 0xa683
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xa536
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/utils/ParallelOperator.h
// Function: abcdl::utils::ParallelOperator<int>::parallel_mul2one_copy(int*, int const*, unsigned long, std::function<void (int*, int const&)> const&) const
void parallel_mul2one_copy(T* result_data,
                               const T* op1,
                               const size_t num_op1,
                               const std::function<void(T*, const T&)> &f) const{
        size_t block_size = get_block_size(num_op1);
        size_t num_thread = get_num_thread(num_op1, block_size);
        std::vector<std::thread> threads(num_thread);

        for(size_t i = 0; i != num_thread; i++){
            threads[i] = std::thread(
                [&result_data, &op1, &f](size_t start_idx, size_t end_idx){
                    for(size_t ti = start_idx; ti != end_idx; ti++){
                        f(&result_data[ti], op1[ti]);
                    }
                }, i * block_size, std::min(num_op1, (i + 1) * block_size)
            );
        }

        for(auto& thread : threads){
            thread.join();
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbx
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x8(%rsp)
movq (%rdi), %r14
movq 0x8(%rdi), %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %r14
cmpq $0x1, %rdx
sbbq $-0x1, %rax
cmpq %rcx, %rsi
movq %rcx, %rbp
cmovbq %rsi, %rbp
cmpq %rsi, %rax
cmovaeq %rax, %rbp
cmpq %rbp, %rsi
jb 0xa78a
movq %rcx, %rax
xorl %edx, %edx
divq %rbp
movq %rax, %r14
cmpq $0x1, %rdx
sbbq $-0x1, %r14
leaq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movq %r14, %rsi
callq 0xa43e
testq %r14, %r14
je 0xa812
xorl %r15d, %r15d
leaq 0x18(%rsp), %r13
xorl %r12d, %r12d
leaq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x58(%rsp)
movq %rbx, 0x60(%rsp)
movq %r15, 0x18(%rsp)
addq %rbp, %r15
movq %r15, 0x10(%rsp)
leaq 0x10(%rsp), %rcx
cmpq 0x8(%rsp), %r15
jb 0xa7e3
leaq 0x8(%rsp), %rcx
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %r13, %rdx
callq 0xa864
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax,%r12,8)
jne 0xa848
movq 0x20(%rsp), %rcx
movq %rcx, (%rax,%r12,8)
incq %r12
cmpq %r12, %r14
jne 0xa7ac
movq 0x28(%rsp), %rbx
movq 0x30(%rsp), %r14
cmpq %r14, %rbx
je 0xa82f
movq %rbx, %rdi
callq 0x95a0
addq $0x8, %rbx
jmp 0xa81c
leaq 0x28(%rsp), %rdi
callq 0xa536
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90c0
jmp 0xa84f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa536
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/utils/ParallelOperator.h
// Function: abcdl::utils::ParallelOperator<int>::parallel_mul2one_copy(int*, int const*, unsigned long, int const&, std::function<void (int*, int const&, int const&)> const&) const
void parallel_mul2one_copy(T* result_data,
                               const T* op1,
                               const size_t num_op1,
                               const T& op2,
                               const std::function<void(T*, const T&, const T&)> &f) const{
        size_t block_size = get_block_size(num_op1);
        size_t num_thread = get_num_thread(num_op1, block_size);
        std::vector<std::thread> threads(num_thread);

        for(size_t i = 0; i != num_thread; i++){
            threads[i] = std::thread(
                [&result_data, &op1, &f, &op2](size_t start_idx, size_t end_idx){
                    for(size_t ti = start_idx; ti != end_idx; ti++){
                        f(&result_data[ti], op1[ti], op2);
                    }
                }, i * block_size, std::min(num_op1, (i + 1) * block_size)
            );
        }

        for(auto& thread : threads){
            thread.join();
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, (%rsp)
movq (%rdi), %r15
movq 0x8(%rdi), %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %r15
cmpq $0x1, %rdx
sbbq $-0x1, %rax
cmpq %rcx, %rsi
movq %rcx, %r12
cmovbq %rsi, %r12
cmpq %rsi, %rax
cmovaeq %rax, %r12
cmpq %r12, %rsi
jb 0xa958
movq %rcx, %rax
xorl %edx, %edx
divq %r12
movq %rax, %r15
cmpq $0x1, %rdx
sbbq $-0x1, %r15
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r15, %rsi
callq 0xa43e
testq %r15, %r15
je 0xa9de
xorl %r13d, %r13d
xorl %ebp, %ebp
leaq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
movq %rbx, 0x58(%rsp)
movq %r14, 0x60(%rsp)
movq %r13, 0x10(%rsp)
addq %r12, %r13
movq %r13, 0x8(%rsp)
leaq 0x8(%rsp), %rcx
cmpq (%rsp), %r13
jb 0xa9ad
movq %rsp, %rcx
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0xaa30
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax,%rbp,8)
jne 0xaa14
movq 0x18(%rsp), %rcx
movq %rcx, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r15
jne 0xa974
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %r14
cmpq %r14, %rbx
je 0xa9fb
movq %rbx, %rdi
callq 0x95a0
addq $0x8, %rbx
jmp 0xa9e8
leaq 0x20(%rsp), %rdi
callq 0xa536
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90c0
jmp 0xaa1b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xa536
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/utils/ParallelOperator.h
// Function: abcdl::utils::ParallelOperator<int>::parallel_mul2mul(int*, unsigned long, int const*, unsigned long, std::function<void (int*, int const&)> const&) const
void parallel_mul2mul(T* op1,
                          const size_t num_op1,
                          const T* op2,
                          const size_t num_op2,
                          const std::function<void(T*, const T&)> &f) const{
        CHECK(num_op1 == num_op2);
        size_t block_size = get_block_size(num_op1);
        size_t num_thread = get_num_thread(num_op1, block_size);
        std::vector<std::thread> threads(num_thread);

        for(size_t i = 0; i != num_thread; i++){
            threads[i] = std::thread(
                [&op1, &op2, &f](size_t start_idx, size_t end_idx){
                    for(size_t ti = start_idx; ti != end_idx; ti++){
                        f(&op1[ti], op2[ti]);
                    }
                }, i * block_size, std::min(num_op1, (i + 1) * block_size)
            );
        }

        for(auto& thread : threads){
            thread.join();
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %r9, 0x8(%rsp)
movq %rdx, %r15
movq %rdi, %r12
movq %rsi, 0x30(%rsp)
movq %rdx, (%rsp)
movq %rcx, 0x28(%rsp)
cmpq %r8, %rdx
jne 0xac02
movq (%r12), %r14
movq 0x8(%r12), %rcx
movq %r15, %rax
xorl %edx, %edx
divq %r14
cmpq $0x1, %rdx
sbbq $-0x1, %rax
cmpq %r15, %rcx
movq %r15, %rbp
cmovbq %rcx, %rbp
cmpq %rcx, %rax
cmovaeq %rax, %rbp
cmpq %rbp, %rcx
jb 0xab39
movq %r15, %rax
xorl %edx, %edx
divq %rbp
movq %rax, %r14
cmpq $0x1, %rdx
sbbq $-0x1, %r14
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %r14, %rsi
callq 0xa43e
testq %r14, %r14
je 0xabc9
xorl %ebx, %ebx
leaq 0x38(%rsp), %r12
leaq 0x18(%rsp), %r13
xorl %r15d, %r15d
leaq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %rbx, 0x18(%rsp)
addq %rbp, %rbx
movq %rbx, 0x10(%rsp)
leaq 0x10(%rsp), %rcx
cmpq (%rsp), %rbx
jb 0xab98
movq %rsp, %rcx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xac74
movq 0x50(%rsp), %rax
cmpq $0x0, (%rax,%r15,8)
jne 0xac43
movq 0x20(%rsp), %rcx
movq %rcx, (%rax,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0xab5f
movq 0x50(%rsp), %rbx
movq 0x58(%rsp), %r14
cmpq %r14, %rbx
je 0xabe6
movq %rbx, %rdi
callq 0x95a0
addq $0x8, %rbx
jmp 0xabd3
leaq 0x50(%rsp), %rdi
callq 0xa536
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f417(%rip), %rsi     # 0x3a020
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl $0x83, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x2f41a(%rip), %rsi     # 0x3a041
movl $0x20, %edx
movq %r14, %rdi
callq 0x93b0
leaq 0x50(%rsp), %rdi
callq 0x389de
jmp 0xaaf7
callq 0x90c0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x389de
jmp 0xac6b
movq %rax, %rbx
jmp 0xac6b
jmp 0xac5e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa536
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/utils/ParallelOperator.h
// Function: abcdl::utils::ParallelOperator<int>::parallel_reduce_mul2one(int*, int const*, unsigned long, std::function<void (int*, int const&)> const&) const
void parallel_reduce_mul2one(T* result_value,
                                 const T* op1,
                         		 const size_t num_op1,
                         		 const std::function<void(T*, const T&)> &f) const{
        size_t block_size = get_block_size(num_op1);
        size_t num_thread = get_num_thread(num_op1, block_size);
        std::vector<std::thread> threads(num_thread);
		T* data = new T[num_thread];

        for(size_t i = 0; i != num_thread; i++){
            threads[i] = std::thread(
                [&op1, &result_value, &data, i, &f](size_t start_idx, size_t end_idx){
					for(size_t ti = start_idx; ti != end_idx; ti++){
            			if(ti == start_idx){
							data[i] = op1[ti];
						}else{
    						f(&data[i], op1[ti]);
                        }
                    }
					f(result_value, data[i]);
                }, i * block_size, std::min(num_op1, (i + 1) * block_size)
            );
        }

        for(auto& thread : threads){
            thread.join();
        }
		delete[] data;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, 0x18(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x10(%rsp)
movq (%rdi), %r14
movq 0x8(%rdi), %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %r14
cmpq $0x1, %rdx
sbbq $-0x1, %rax
cmpq %rcx, %rsi
movq %rcx, %rbp
cmovbq %rsi, %rbp
cmpq %rsi, %rax
cmovaeq %rax, %rbp
cmpq %rbp, %rsi
jb 0xb259
movq %rcx, %rax
xorl %edx, %edx
divq %rbp
movq %rax, %r14
cmpq $0x1, %rdx
sbbq $-0x1, %r14
leaq 0x38(%rsp), %rdi
leaq 0x60(%rsp), %rdx
movq %r14, %rsi
callq 0xa43e
movq %r14, %rax
shrq $0x3e, %rax
leaq (,%r14,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
movq %rax, 0x8(%rsp)
testq %r14, %r14
je 0xb322
xorl %ebx, %ebx
leaq 0x60(%rsp), %r12
leaq 0x28(%rsp), %r13
xorl %r15d, %r15d
leaq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x8(%rsp), %rax
movq %rax, 0x70(%rsp)
movq %r15, 0x78(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x80(%rsp)
movq %rbx, 0x28(%rsp)
addq %rbp, %rbx
movq %rbx, 0x20(%rsp)
leaq 0x20(%rsp), %rcx
cmpq 0x10(%rsp), %rbx
jb 0xb2f5
leaq 0x10(%rsp), %rcx
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xb388
movq 0x38(%rsp), %rax
cmpq $0x0, (%rax,%r15,8)
jne 0xb36a
movq 0x30(%rsp), %rcx
movq %rcx, (%rax,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0xb2a7
movq 0x38(%rsp), %rbx
movq 0x40(%rsp), %r14
cmpq %r14, %rbx
je 0xb33f
movq %rbx, %rdi
callq 0x95a0
addq $0x8, %rbx
jmp 0xb32c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb34e
callq 0x9420
leaq 0x38(%rsp), %rdi
callq 0xa536
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90c0
jmp 0xb373
jmp 0xb373
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xa536
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/fnn/Layer.h
// Function: abcdl::fnn::OutputLayer::OutputLayer(unsigned long, unsigned long, abcdl::framework::ActivateFunc*, abcdl::framework::Cost*, float const&, float const&)
OutputLayer(const size_t input_dim,
                const size_t output_dim,
                abcdl::framework::ActivateFunc* activate_func,
                abcdl::framework::Cost* cost,
                const real& mean_value = 0.0f,
                const real& stddev = 0.5f) : Layer(input_dim, output_dim, abcdl::framework::OUTPUT){
        _cost           = cost;
        _activate_func  = activate_func;

        this->_weight.reset(_input_dim, _output_dim, mean_value, stddev);
        this->_bias.reset(1, _output_dim, mean_value, stddev);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %rbp
movq %rcx, %r13
movq %rdi, %rbx
movl $0x4, %ecx
callq 0x11022
leaq 0x467c5(%rip), %rax     # 0x56d08
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x178(%rbx), %r14
movq %r14, %rdi
callq 0x197e0
movq 0x50(%rsp), %r12
movq %rbp, 0x170(%rbx)
movq %r13, 0x168(%rbx)
leaq 0x30(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
xorl %ebp, %ebp
leaq 0x14(%rsp), %r9
movl %ebp, (%r9)
leaq 0x10(%rsp), %r13
movl %ebp, (%r13)
movq %r13, (%rsp)
movq %r15, %rcx
movq %r12, %r8
callq 0x1dc0c
leaq 0x68(%rbx), %rdi
movq 0x10(%rbx), %rdx
leaq 0x14(%rsp), %r9
movl %ebp, (%r9)
movl %ebp, 0x10(%rsp)
movq %r13, (%rsp)
movl $0x1, %esi
movq %r15, %rcx
movq %r12, %r8
callq 0x1dc0c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x105d3
movq %rax, %r15
movq %r14, %rdi
callq 0x19a36
jmp 0x105e3
movq %rax, %r15
movq %rbx, %rdi
callq 0x11152
movq %r15, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/fnn/FNN.h
// Function: abcdl::fnn::FNN::set_layers(std::vector<abcdl::fnn::Layer*, std::allocator<abcdl::fnn::Layer*>>&)
void set_layers(std::vector<abcdl::fnn::Layer*>& layers){
        size_t layer_size = layers.size();
        CHECK(layer_size > 1 && layers[0]->get_layer_type() == abcdl::framework::INPUT);
        size_t output_dim = layers[0]->get_output_dim();
        for(size_t i = 1; i != layer_size; i++){
            CHECK(layers[i]->get_layer_type() == ((i == layer_size - 1) ? abcdl::framework::OUTPUT : abcdl::framework::FULL_CONN));
            CHECK(output_dim == layers[i]->get_input_dim());
            output_dim = layers[i]->get_output_dim();
        }
        _layers = layers;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %r14
subq %rax, %r14
movq %r14, %r15
sarq $0x3, %r15
cmpq $0x2, %r15
jb 0x1074a
movq (%rax), %rax
cmpl $0x0, 0x18(%rax)
jne 0x1074a
cmpq $0x8, %r14
jne 0x10654
addq $0x30, %rdi
movq %rbx, %rsi
callq 0x11250
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
leaq -0x1(%r15), %r13
addq $-0x2, %r15
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x29a7c(%rip), %rsi     # 0x3a0ea
leaq 0x10(%rsp), %r8
movq %rax, %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %r14
movq 0x8(%rax,%r12,8), %rcx
xorl %edx, %edx
cmpq %r12, %r15
sete %dl
leal (%rdx,%rdx,2), %edx
incl %edx
cmpl %edx, 0x18(%rcx)
jne 0x106ab
cmpq 0x8(%rcx), %r14
jne 0x106fd
leaq (%rax,%rbp,8), %rcx
incq %rbp
incq %r12
cmpq %r12, %r13
jne 0x10676
jmp 0x10636
movq %rdi, 0x8(%rsp)
movq %r8, %rdi
movl $0x39, %edx
movl $0x3, %ecx
callq 0x387b6
movl $0x7d, %edx
leaq 0x10(%rsp), %rdi
leaq 0x29a80(%rip), %rsi     # 0x3a153
callq 0x93b0
leaq 0x10(%rsp), %rdi
callq 0x389de
movq (%rbx), %rax
movq 0x8(%rax,%r12,8), %rcx
movq 0x8(%rsp), %rdi
leaq 0x299f4(%rip), %rsi     # 0x3a0ea
leaq 0x10(%rsp), %r8
jmp 0x10694
movq %rdi, 0x8(%rsp)
movq %r8, %rdi
movl $0x3a, %edx
movl $0x3, %ecx
movq %r8, %r14
callq 0x387b6
movl $0x36, %edx
movq %r14, %rdi
leaq 0x29aab(%rip), %rsi     # 0x3a1d1
callq 0x93b0
movq %r14, %rdi
callq 0x389de
movq (%rbx), %rax
movq 0x8(%rsp), %rdi
leaq 0x299a8(%rip), %rsi     # 0x3a0ea
movq %r14, %r8
jmp 0x1069a
movq %rdi, %r13
leaq 0x29996(%rip), %rsi     # 0x3a0ea
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl $0x36, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x2998a(%rip), %rsi     # 0x3a0fc
movl $0x56, %edx
movq %r12, %rdi
callq 0x93b0
leaq 0x10(%rsp), %rdi
callq 0x389de
movq %r13, %rdi
jmp 0x10630
jmp 0x10795
jmp 0x10795
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x389de
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/fnn/FNN.h
// Function: abcdl::fnn::FNN::~FNN()
~FNN(){
        for(auto& layer : _layers){
            delete layer;
			layer = nullptr;
        }
        _layers.clear();

        if(_loss != nullptr){
            delete _loss;
            _loss = nullptr;
        }

    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %r14
movq 0x38(%rdi), %r15
cmpq %r15, %r14
je 0x10f3d
movq (%r14), %rdi
testq %rdi, %rdi
je 0x10f1f
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%r14)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x10f11
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x10f3d
movq %rax, 0x38(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x10f54
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x48(%rbx)
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x10f66
callq 0x9350
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x10f74
callq 0x9350
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x10f8b
popq %rbx
popq %r14
popq %r15
jmp 0x9350
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/utils/MnistHelper.h
// Function: abcdl::utils::MnistHelper<float>::read_label(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, abcdl::algebra::Matrix<float>*, int)
bool MnistHelper<T>::read_label(const std::string& label_file,
                                abcdl::algebra::Matrix<T>* out_mat,
                                const int limit){
    size_t count = 0;
    auto label_buffer = read_mnist_file(label_file, 0x801, &count);
    if(!label_buffer || count == 0){
        return false;
    }

    if( limit > 0 && limit < (int)count){
        count = limit;
    }

    //read label data
    auto label_data_buffer = reinterpret_cast<unsigned char*>(label_buffer.get() + 8);

    T* labels = new T[count];
    for(size_t i = 0; i < count; i++){
        labels[i] = static_cast<T>(*label_data_buffer++);
    }

    out_mat->set_shallow_data(labels, count, 1);

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %rsp, %r15
movq %r15, %rdi
movl $0x801, %ecx            # imm = 0x801
movq %rbx, %r8
callq 0x11f4c
movq (%r15), %r15
testq %r15, %r15
setne %al
movq (%rbx), %r12
testq %r12, %r12
setne %bl
andb %al, %bl
cmpb $0x1, %bl
jne 0x12727
testl %ebp, %ebp
setg %al
cmpl %ebp, %r12d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x126d5
movl %ebp, %r12d
movq %r12, 0x8(%rsp)
movq %r12, %rax
shrq $0x3e, %rax
leaq (,%r12,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
xorl %ecx, %ecx
movzbl 0x8(%r15,%rcx), %edx
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
movss %xmm0, (%rax,%rcx,4)
incq %rcx
cmpq %rcx, %r12
jne 0x126f6
movl $0x1, %ecx
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x19db2
movq (%rsp), %r15
testq %r15, %r15
je 0x12734
movq %r15, %rdi
callq 0x9420
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x12754
callq 0x9420
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/utils/MnistHelper.h
// Function: abcdl::utils::MnistHelper<float>::read_vec_labels(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, abcdl::algebra::MatrixSet<float>&, int, unsigned long)
bool MnistHelper<T>::read_vec_labels(const std::string& label_file,
                                     abcdl::algebra::MatrixSet<T>& out_matrix_set,
                                     const int limit,
                                     const size_t vec_size){
    size_t count = 0;
    auto label_buffer = read_mnist_file(label_file, 0x801, &count);
    if(!label_buffer || count == 0){
        return false;
    }

    if( limit > 0 && limit < (int)count){
        count = limit;
    }

    //read label data
    auto label_data_buffer = reinterpret_cast<unsigned char*>(label_buffer.get() + 8);

    T* labels = new T[vec_size];
    for(size_t i = 0; i < count; i++){
        memset(labels, 0, sizeof(T) * vec_size);
        auto label = static_cast<size_t>(*label_data_buffer++);
        labels[label] = 1;
        out_matrix_set.push_back(abcdl::algebra::Matrix<T>(labels, 1, vec_size));
    }
    delete[] labels;

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, 0x18(%rsp)
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r13
movq $0x0, (%r13)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl $0x801, %ecx            # imm = 0x801
movq %r13, %r8
callq 0x11f4c
movq (%r12), %r12
testq %r12, %r12
setne %cl
movq (%r13), %rax
testq %rax, %rax
setne %bpl
andb %cl, %bpl
cmpb $0x1, %bpl
jne 0x12863
movb %bpl, 0x7(%rsp)
testl %ebx, %ebx
setg %cl
cmpl %ebx, %eax
setg %al
andb %cl, %al
cmpb $0x1, %al
jne 0x127da
movl %ebx, %eax
movq %rax, 0x10(%rsp)
movq %r14, %rax
shrq $0x3e, %rax
leaq (,%r14,4), %r13
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r13, %rdi
callq 0x9030
movq %rax, %rbp
xorl %r15d, %r15d
leaq 0x20(%rsp), %rbx
movq %rbp, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x91d0
movzbl 0x8(%r12,%r15), %eax
movl $0x3f800000, (%rbp,%rax,4) # imm = 0x3F800000
movl $0x1, %edx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rcx
callq 0x19968
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x12204
movq %rbx, %rdi
callq 0x19a36
incq %r15
cmpq 0x10(%rsp), %r15
jb 0x12804
movq %rbp, %rdi
callq 0x9420
movq 0x8(%rsp), %r12
movb 0x7(%rsp), %bpl
testq %r12, %r12
je 0x12870
movq %r12, %rdi
callq 0x9420
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12883
movq %rax, %rbx
jmp 0x12895
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x19a36
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x128a4
callq 0x9420
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/utils/MnistHelper.h
// Function: abcdl::utils::MnistHelper<float>::read_vec_label(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, abcdl::algebra::Matrix<float>*, int, unsigned long)
bool MnistHelper<T>::read_vec_label(const std::string& label_file,
                                    abcdl::algebra::Matrix<T>* out_mat,
                                    const int limit,
                                    const size_t vec_size){
    size_t count = 0;
    auto label_buffer = read_mnist_file(label_file, 0x801, &count);
    if(!label_buffer || count == 0){
        return false;
    }

    if( limit > 0 && limit < (int)count){
        count = limit;
    }

    //read label data
    auto label_data_buffer = reinterpret_cast<unsigned char*>(label_buffer.get() + 8);

    T* labels = new T[count * vec_size];
    memset(labels, 0, sizeof(T) * count * vec_size);

    for(size_t i = 0; i < count; i++){
        auto label = static_cast<size_t>(*label_data_buffer++);
        labels[i * vec_size + label] = 1;
    }

    out_mat->set_shallow_data(labels, count, vec_size);

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x20(%rsp), %rbx
movq $0x0, (%rbx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl $0x801, %ecx            # imm = 0x801
movq %rbx, %r8
callq 0x11f4c
movq (%r12), %r12
testq %r12, %r12
setne %al
movq (%rbx), %r13
testq %r13, %r13
setne %bl
andb %al, %bl
cmpb $0x1, %bl
jne 0x149e3
testl %ebp, %ebp
setg %al
cmpl %ebp, %r13d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x14963
movl %ebp, %r13d
movq %r13, 0x20(%rsp)
movq %r15, 0x18(%rsp)
movq %r13, %rax
imulq %r14, %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x9030
movq %rax, %rbp
movq %r14, 0x10(%rsp)
leaq (,%r14,4), %r15
movq %r15, %rdx
imulq %r13, %rdx
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
callq 0x91d0
movq %rbp, %rax
movzbl 0x8(%r12,%r14), %ecx
movl $0x3f800000, (%rax,%rcx,4) # imm = 0x3F800000
incq %r14
addq %r15, %rax
cmpq %r14, %r13
jne 0x149b1
movq 0x18(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq 0x10(%rsp), %rcx
callq 0x19db2
movq 0x8(%rsp), %r12
testq %r12, %r12
je 0x149f0
movq %r12, %rdi
callq 0x9420
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x14a13
callq 0x9420
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/src/fnn/Layer.cpp
// Function: abcdl::fnn::FullConnLayer::backward(abcdl::fnn::Layer*, abcdl::fnn::Layer*)
void FullConnLayer::backward(Layer* pre_layer, Layer* next_layer){
    //δ_l = ( (w_l+1).T .* δ_l+1 ) * Derivative(a_l)
    abcdl::algebra::Mat activate_derivative;
    _activate_func->derivative(activate_derivative, this->_activate_data);
    _delta_bias   = _helper.dot(next_layer->get_delta_bias(), next_layer->get_weight().Ts()) * activate_derivative;

    /*
     * Derivative(Cw) = a_in * δ_out
     * a_in = a_l-1, δ_out = mat
     * activations include input layer, so l-1 is i.
     */
    this->_delta_weight   = _helper.dot(pre_layer->get_activate_data().Ts(), this->_delta_bias);

    this->_batch_bias     += this->_delta_bias;
    this->_batch_weight   += this->_delta_weight;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x80(%rsp), %r12
movq %r12, %rdi
callq 0x197e0
movq 0x168(%rbx), %rdi
leaq 0xa0(%rbx), %rdx
movq (%rdi), %rax
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x30(%r15), %rsi
leaq 0x58(%rsp), %rdi
callq 0x1aace
leaq 0x20(%rbx), %r12
addq $0xf0, %r15
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rcx
movq %r12, %rsi
movq %r15, %rdx
callq 0x30468
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x22482
leaq 0xf0(%rbx), %r15
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x21422
leaq 0x30(%rsp), %rdi
callq 0x19a36
leaq 0x8(%rsp), %rdi
callq 0x19a36
leaq 0x58(%rsp), %rdi
callq 0x19a36
addq $0xa0, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1aace
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
movq %r15, %rcx
callq 0x30468
leaq 0xc8(%rbx), %r14
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x21422
leaq 0x30(%rsp), %rdi
callq 0x19a36
leaq 0x8(%rsp), %rdi
callq 0x19a36
leaq 0x140(%rbx), %rdi
movq %r15, %rsi
callq 0x21928
addq $0x118, %rbx            # imm = 0x118
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21928
leaq 0x80(%rsp), %rdi
callq 0x19a36
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x19a36
jmp 0x14c95
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x14cc4
jmp 0x14ccd
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x19a36
jmp 0x14cb0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x19a36
jmp 0x14cbf
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x19a36
jmp 0x14cd0
jmp 0x14ccd
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x19a36
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/src/fnn/Layer.cpp
// Function: abcdl::fnn::OutputLayer::backward(abcdl::fnn::Layer*, abcdl::fnn::Layer*)
void OutputLayer::backward(Layer* pre_layer, Layer* next_layer){
    /*
     * L layer(last layer) Error
     * Error δL = cost->delta
     */
    _cost->delta(this->_delta_bias, this->_activate_data, this->_y);
    /*
     * Derivative(Cw) = a_in * δ_out
     * a_in = a_L-1, δ_out = delta
     */
    this->_delta_weight   = _helper.dot(pre_layer->get_activate_data().Ts(), this->_delta_bias);

    this->_batch_weight   += this->_delta_weight;
    this->_batch_bias     += this->_delta_bias;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x170(%rdi), %rdi
leaq 0xf0(%rbx), %r14
movl $0xa0, %r12d
leaq (%rbx,%r12), %rdx
leaq 0x178(%rbx), %rcx
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
leaq 0x20(%rbx), %r13
addq %r15, %r12
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1aace
movq %rsp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x30468
leaq 0xc8(%rbx), %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x21422
movq %rsp, %rdi
callq 0x19a36
leaq 0x28(%rsp), %rdi
callq 0x19a36
leaq 0x118(%rbx), %rdi
movq %r15, %rsi
callq 0x21928
addq $0x140, %rbx            # imm = 0x140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21928
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19a36
jmp 0x14e42
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x19a36
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/utils/Shuffler.h
// Function: abcdl::utils::Shuffler::shuffle()
void Shuffler::shuffle(){

    std::random_device rd;
    size_t random_idx, value;

    for(size_t i = _size - 1; i != 0 ; i--){
        random_idx = rd() % i;
        value =  _shuffler_idx[random_idx];

        _shuffler_idx[random_idx] = _shuffler_idx[i];
        _shuffler_idx[i] = value;
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1390, %rsp           # imm = 0x1390
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x16d0a
movq (%rbx), %r15
decq %r15
je 0x1535e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x9460
movl %eax, %eax
xorl %edx, %edx
divq %r15
movq 0x8(%rbx), %rax
movq (%rax,%rdx,8), %rcx
movq (%rax,%r15,8), %rsi
movq %rsi, (%rax,%rdx,8)
movq %rcx, (%rax,%r15,8)
decq %r15
jne 0x15336
leaq 0x8(%rsp), %rdi
callq 0x9340
addq $0x1390, %rsp           # imm = 0x1390
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1538c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9340
movq %rbx, %rdi
callq 0x95d0
movq %rax, %rdi
callq 0x10f91
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/src/fnn/FNN.cpp
// Function: abcdl::fnn::FNN::predict(abcdl::algebra::Matrix<float>&, abcdl::algebra::Matrix<float> const&)
void FNN::predict(abcdl::algebra::Mat& result, const abcdl::algebra::Mat& predict_data){
    CHECK(predict_data.cols() == _layers[0]->get_input_dim());
    size_t layer_size = _layers.size();
    for(size_t k = 0; k < layer_size; k++){
        if(k == 0){
            ((InputLayer*)_layers[k])->set_x(predict_data);
        }
        _layers[k]->forward(_layers[k-1]);
        if(k > 0){
            //_layers[k]->get_activate_data().display("|");
        }
    }
    //predict_data.display("^");
    //_layers[layer_size - 1]->get_activate_data().display("|");
    result = _layers[layer_size - 1]->get_activate_data();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdx), %rcx
movq 0x30(%rdi), %rax
movq (%rax), %rdx
cmpq 0x8(%rdx), %rcx
jne 0x162fb
movq 0x38(%r15), %r12
subq %rax, %r12
je 0x162d7
movq %rbx, 0x8(%rsp)
movq %r12, %rax
sarq $0x3, %rax
xorl %r13d, %r13d
cmpq $0x1, %rax
movl $0x0, %ebp
sbbq %rax, %rbp
xorl %ebx, %ebx
movq 0x30(%r15), %rax
subq $0x1, %rbx
jae 0x162b3
movq (%rax), %rdi
movq %r14, %rsi
callq 0x14a1c
movq 0x30(%r15), %rax
movq %rax, %rcx
jmp 0x162b7
leaq (%rax,%r13), %rcx
movq (%rcx), %rdi
movq -0x8(%rax,%r13), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r13
cmpq %rbx, %rbp
jne 0x16295
movq 0x30(%r15), %rax
movq 0x8(%rsp), %rbx
movl $0xa0, %esi
addq -0x8(%rax,%r12), %rsi
movq %rbx, %rdi
callq 0x21422
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25cee(%rip), %rsi     # 0x3bff0
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl $0x86, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x25f63(%rip), %rsi     # 0x3c283
movl $0x40, %edx
movq %r12, %rdi
callq 0x93b0
leaq 0x10(%rsp), %rdi
callq 0x389de
movq 0x30(%r15), %rax
jmp 0x1626f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x389de
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/src/fnn/FNN.cpp
// Function: abcdl::fnn::FNN::write_model(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool FNN::write_model(const std::string& path){
    std::vector<abcdl::algebra::Mat*> params;
    for(size_t i = 1; i != _layers.size(); i++){
        params.push_back(&_layers[i]->get_weight());
        params.push_back(&_layers[i]->get_bias());
    }
    return _model_loader.write<real>(params, path, "FNNMODEL", false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
je 0x168a7
movl $0x1, %r13d
movq %rsp, %r15
leaq 0x18(%rsp), %r12
movq (%rax,%r13,8), %rax
addq $0x30, %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x1684e
movq %rax, (%rsi)
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x1685e
movq %r15, %rdi
movq %r12, %rdx
callq 0x180ce
movq 0x8(%rsp), %rsi
movq 0x30(%r14), %rax
movq (%rax,%r13,8), %rax
addq $0x68, %rax
movq %rax, 0x18(%rsp)
cmpq 0x10(%rsp), %rsi
je 0x16881
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x1688c
movq %r15, %rdi
movq %r12, %rdx
callq 0x180ce
incq %r13
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jne 0x16822
leaq 0x38(%rsp), %rdi
movq %rsp, %rsi
callq 0x17a24
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x25a14(%rip), %rsi     # 0x3c2d8
leaq 0x25a15(%rip), %rdx     # 0x3c2e0
leaq 0x18(%rsp), %rdi
callq 0x145ac
addq $0x50, %r14
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0x174a2
movl %eax, %ebx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x16902
callq 0x9350
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x16911
callq 0x9350
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1691f
callq 0x9350
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x16946
callq 0x9350
jmp 0x16946
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1695e
callq 0x9350
jmp 0x1695e
jmp 0x1695b
jmp 0x1695b
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1696c
callq 0x9350
movq %rbx, %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/fnn/Layer.h
// Function: abcdl::fnn::Layer::update_gradient(unsigned long, float)
void update_gradient(const size_t batch_size,
                         const real learning_rate){
		real lr = learning_rate / batch_size;
        _weight -= _batch_weight * lr;
        _bias   -= _batch_bias * lr;
        
		_batch_weight.reset(0);
        _batch_bias.reset(0);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
js 0x16d8f
cvtsi2ss %rsi, %xmm1
jmp 0x16da4
movq %rsi, %rax
shrq %rax
andl $0x1, %esi
orq %rax, %rsi
cvtsi2ss %rsi, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
leaq 0x4(%rsp), %rdx
movss %xmm0, (%rdx)
leaq 0x118(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x223d8
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x220e2
leaq 0x8(%rsp), %rdi
callq 0x19a36
leaq 0x140(%rbx), %r15
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x223d8
addq $0x68, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x220e2
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x19a36
xorl %ebp, %ebp
movl %ebp, (%rbx)
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a96a
movl %ebp, (%rbx)
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x1a96a
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16e48
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x19a36
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/fnn/Layer.h
// Function: abcdl::fnn::Layer::set_weight(abcdl::algebra::Matrix<float> const&)
bool set_weight(const abcdl::algebra::Mat& weight){
        if(weight.rows() != _weight.rows()){
            LOG(FATAL) << "set weight rows error:" << weight.rows() << " must be:" << _weight.rows();
            return false;
        }
        if(weight.cols() != _weight.cols()){
            LOG(FATAL) << "set weight cols error:" << weight.cols() << " must be:" << _weight.cols();
            return false;
        }
        _weight = weight;
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %rbx
movq (%rsi), %rax
leaq 0x30(%rdi), %r14
cmpq 0x30(%rdi), %rax
jne 0x17265
movq %rdi, %r15
movq 0x8(%rbx), %rax
cmpq 0x38(%rdi), %rax
jne 0x172c9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17aa4
movb $0x1, %al
jmp 0x17339
leaq 0x25115(%rip), %rsi     # 0x3c381
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x31, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x2510b(%rip), %rsi     # 0x3c395
movl $0x16, %edx
movq %r15, %rdi
callq 0x93b0
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9200
leaq 0x2505d(%rip), %rsi     # 0x3c308
leaq 0x8(%rsp), %rdi
movl $0x9, %edx
callq 0x93b0
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9200
jmp 0x1732d
leaq 0x250b1(%rip), %rsi     # 0x3c381
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x35, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x250be(%rip), %rsi     # 0x3c3ac
movl $0x16, %edx
movq %r14, %rdi
callq 0x93b0
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9200
leaq 0x24ff8(%rip), %rsi     # 0x3c308
leaq 0x8(%rsp), %rdi
movl $0x9, %edx
callq 0x93b0
movq 0x38(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9200
leaq 0x8(%rsp), %rdi
callq 0x389de
xorl %eax, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
jmp 0x17350
jmp 0x17350
jmp 0x17350
jmp 0x17350
jmp 0x17350
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x389de
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/fnn/Layer.h
// Function: abcdl::fnn::Layer::set_bias(abcdl::algebra::Matrix<float> const&)
bool set_bias(const abcdl::algebra::Mat& bias){
        if(bias.rows() != _bias.rows()){
            LOG(FATAL) << "set bias rows error:" << bias.rows() << " must be:" << _bias.rows();
            return false;
        }
        if(bias.cols() != _bias.cols()){
            LOG(FATAL) << "set bias cols error:" << bias.cols() << " must be:" << _bias.cols();
            return false;
        }
        _bias = bias;
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %rbx
movq (%rsi), %rax
leaq 0x68(%rdi), %r14
cmpq 0x68(%rdi), %rax
jne 0x173a1
movq %rdi, %r15
movq 0x8(%rbx), %rax
cmpq 0x70(%rdi), %rax
jne 0x17405
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17aa4
movb $0x1, %al
jmp 0x17475
leaq 0x24fd9(%rip), %rsi     # 0x3c381
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x3f, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x24ffd(%rip), %rsi     # 0x3c3c3
movl $0x14, %edx
movq %r15, %rdi
callq 0x93b0
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9200
leaq 0x24f21(%rip), %rsi     # 0x3c308
leaq 0x8(%rsp), %rdi
movl $0x9, %edx
callq 0x93b0
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9200
jmp 0x17469
leaq 0x24f75(%rip), %rsi     # 0x3c381
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x43, %edx
movl $0x3, %ecx
callq 0x387b6
leaq 0x24fae(%rip), %rsi     # 0x3c3d8
movl $0x14, %edx
movq %r14, %rdi
callq 0x93b0
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9200
leaq 0x24ebc(%rip), %rsi     # 0x3c308
leaq 0x8(%rsp), %rdi
movl $0x9, %edx
callq 0x93b0
movq 0x70(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9200
leaq 0x8(%rsp), %rdi
callq 0x389de
xorl %eax, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1748c
jmp 0x1748c
jmp 0x1748c
jmp 0x1748c
jmp 0x1748c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x389de
movq %rbx, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/include/algebra/Matrix.h
// Function: abcdl::algebra::RandomMatrix<float>::operator=(abcdl::algebra::Matrix<float> const&)
RandomMatrix<T>& operator = (const Matrix<T>& mat){
        if(this->get_size() != mat.get_size()){
            if(this->_data != nullptr){
                delete[] this->_data;
            }
            this->_data = new T[mat.get_size()];
        }
        this->_rows = mat.rows();
        this->_cols = mat.cols();
        memcpy(this->_data, mat.data(), sizeof(T) * mat.get_size());

        return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
imulq (%rbx), %rcx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
movq %r12, %rax
imulq %r15, %rax
cmpq %rax, %rcx
je 0x17b0b
testq %rdi, %rdi
je 0x17ae9
callq 0x9420
movq (%r14), %r15
movq 0x8(%r14), %r12
movq %r12, %rax
imulq %r15, %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x9030
movq %rax, %rdi
movq %rax, 0x10(%rbx)
movq %r15, (%rbx)
movq %r12, 0x8(%rbx)
movq (%r14), %rdx
movq 0x10(%r14), %rsi
imulq 0x8(%r14), %rdx
shlq $0x2, %rdx
callq 0x92b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/btbujiangjun[P]abcdl/src/algebra/MatrixBase.cpp
// Function: abcdl::algebra::Matrix<int>::Matrix(unsigned long, unsigned long)
Matrix<T>::Matrix(const size_t rows, const size_t cols){
    _rows = rows;
    _cols = cols;
    _data = new T[_rows * _cols];
    memset(_data, 0, sizeof(T) * _rows * _cols);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x18, %rdi
callq 0xa2ae
movq %r14, (%r15)
movq %rbx, 0x8(%r15)
imulq %r14, %rbx
movq %rbx, %rax
shrq $0x3e, %rax
shlq $0x2, %rbx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rbx, %rdi
callq 0x9030
movq %rax, 0x10(%r15)
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x91d0
nop