LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Distrotech[P]stund/stun.cxx
// Function: stunCreateUserName(StunAddress4 const&, StunAtrString*)
void
stunCreateUserName(const StunAddress4& source, StunAtrString* username)
{
   UInt64 time = stunGetSystemTimeSecs();
   time -= (time % 20*60);
   //UInt64 hitime = time >> 32;
   UInt64 lotime = time & 0xFFFFFFFF;
	
   char buffer[1024];
   sprintf(buffer,
           "%08x:%08x:%08x:", 
           UInt32(source.addr),
           UInt32(stunRand()),
           UInt32(lotime));
   assert( strlen(buffer) < 1024 );
	
   assert(strlen(buffer) + 41 < STUN_MAX_STRING);
	
   char hmac[20];
   char key[] = "Jason";
   computeHmac(hmac, buffer, strlen(buffer), key, strlen(key) );
   char hmacHex[41];
   toHex(hmac, 20, hmacHex );
   hmacHex[40] =0;
	
   strcat(buffer,hmacHex);
	
   int l = strlen(buffer);
   assert( l+1 < STUN_MAX_STRING );
   assert( l%4 == 0 );
   
   username->sizeValue = l;
   memcpy(username->value,buffer,l);
   username->value[l]=0;
	
   //if (verbose) clog << "computed username=" << username.value << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
movq %rsi, %rbx
movq %rdi, %r14
callq 0x422f
movq %rax, %r15
pushq $0x14
popq %rcx
xorl %edx, %edx
divq %rcx
imull $-0x3c, %edx, %eax
addl %eax, %r15d
movl 0x4(%r14), %ebp
callq 0x4076
leaq 0x384e(%rip), %rsi      # 0x7964
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %ebp, %edx
movl %eax, %ecx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x2060
movq %r14, %rdi
callq 0x20b0
cmpq $0x400, %rax            # imm = 0x400
jae 0x41b3
cmpq $0xd7, %rax
jae 0x41d2
leaq 0x4221(%rip), %rdi      # 0x8370
movq %rsp, %r14
movq %r14, %rsi
callq 0x424a
movb $0x0, 0x28(%r14)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x22b0
movq %r15, %rdi
callq 0x20b0
cmpl $0xff, %eax
jge 0x41f1
testb $0x3, %al
jne 0x4210
movw %ax, 0x100(%rbx)
movslq %eax, %r14
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2170
movb $0x0, (%rbx,%r14)
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37ba(%rip), %rdi      # 0x7974
leaq 0x358c(%rip), %rsi      # 0x774d
leaq 0x37c2(%rip), %rcx      # 0x798a
movl $0x308, %edx            # imm = 0x308
callq 0x2120
leaq 0x37f0(%rip), %rdi      # 0x79c9
leaq 0x356d(%rip), %rsi      # 0x774d
leaq 0x37a3(%rip), %rcx      # 0x798a
movl $0x30a, %edx            # imm = 0x30A
callq 0x2120
leaq 0x37f7(%rip), %rdi      # 0x79ef
leaq 0x354e(%rip), %rsi      # 0x774d
leaq 0x3784(%rip), %rcx      # 0x798a
movl $0x316, %edx            # imm = 0x316
callq 0x2120
leaq 0x37ee(%rip), %rdi      # 0x7a05
leaq 0x352f(%rip), %rsi      # 0x774d
leaq 0x3765(%rip), %rcx      # 0x798a
movl $0x317, %edx            # imm = 0x317
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/Distrotech[P]stund/stun.cxx
// Function: operator<<(std::ostream&, UInt128 const&)
ostream& operator<< ( ostream& strm, const UInt128& r )
{
   strm << int(r.octet[0]);
   for ( int i=1; i<16; i++ )
   {
      strm << ':' << int(r.octet[i]);
   }
    
   return strm;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %esi
callq 0x22a0
pushq $0x1
popq %r15
pushq $0x3a
popq %rbp
cmpq $0x10, %r15
je 0x42dc
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2200
movzbl (%r14,%r15), %esi
movq %rax, %rdi
callq 0x22a0
incq %r15
jmp 0x42ba
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Distrotech[P]stund/stun.cxx
// Function: stunParseServerName(char*, StunAddress4&)
bool
stunParseServerName( char* name, StunAddress4& addr)
{
   assert(name);
	
   // TODO - put in DNS SRV stuff.
	
   bool ret = stunParseHostName( name, addr.addr, addr.port, 3478); 
   if ( ret != true ) 
   {
       addr.port=0xFFFF;
   }	
   return ret;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x4405
movq %rsi, %rbx
addq $0x4, %rsi
movq %rbx, %rdx
movl $0xd96, %ecx            # imm = 0xD96
callq 0x42ea
testb %al, %al
jne 0x4403
orw $-0x1, (%rbx)
popq %rbx
retq
leaq 0x31b1(%rip), %rdi      # 0x75bd
leaq 0x333a(%rip), %rsi      # 0x774d
leaq 0x35ff(%rip), %rcx      # 0x7a19
movl $0x3c5, %edx            # imm = 0x3C5
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/Distrotech[P]stund/stun.cxx
// Function: stunStopServer(StunServerInfo&)
void
stunStopServer(StunServerInfo& info)
{
   if (info.myFd > 0) closesocket(info.myFd);
   if (info.altPortFd > 0) closesocket(info.altPortFd);
   if (info.altIpFd > 0) closesocket(info.altIpFd);
   if (info.altIpPortFd > 0) closesocket(info.altIpPortFd);
   
   if (info.relay)
   {
      for (int i=0; i<MAX_MEDIA_RELAYS; ++i)
      {
         StunMediaRelay* relay = &info.relays[i];
         if (relay->fd)
         {
            closesocket(relay->fd);
            relay->fd = 0;
         }
      }
   }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %edi
testl %edi, %edi
jle 0x4d33
callq 0x22c0
movl 0x14(%rbx), %edi
testl %edi, %edi
jle 0x4d3f
callq 0x22c0
movl 0x18(%rbx), %edi
testl %edi, %edi
jle 0x4d4b
callq 0x22c0
movl 0x1c(%rbx), %edi
testl %edi, %edi
jle 0x4d57
callq 0x22c0
cmpb $0x1, 0x20(%rbx)
jne 0x4d82
pushq $0x2c
popq %r14
cmpq $0x2f0c, %r14           # imm = 0x2F0C
je 0x4d82
movl (%rbx,%r14), %edi
testl %edi, %edi
je 0x4d7c
callq 0x22c0
andl $0x0, (%rbx,%r14)
addq $0x18, %r14
jmp 0x4d61
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Distrotech[P]stund/stun.cxx
// Function: stunFindLocalInterfaces(unsigned int*, int)
int 
stunFindLocalInterfaces(UInt32* addresses,int maxRet)
{
#if defined(WIN32) || defined(__sparc__)
   return 0;
#else
   struct ifconf ifc;
	
   int s = socket( AF_INET, SOCK_DGRAM, 0 );
   int len = 100 * sizeof(struct ifreq);
	
   char buf[ len ];
	
   ifc.ifc_len = len;
   ifc.ifc_buf = buf;
	
   int e = ioctl(s,SIOCGIFCONF,&ifc);
   char *ptr = buf;
   int tl = ifc.ifc_len;
   int count=0;
	
   while ( (tl > 0) && ( count < maxRet) )
   {
      struct ifreq* ifr = (struct ifreq *)ptr;
		
      int si = sizeof(ifr->ifr_name) + sizeof(struct sockaddr);
      tl -= si;
      ptr += si;
      //char* name = ifr->ifr_ifrn.ifrn_name;
      //cerr << "name = " << name << endl;
		
      struct ifreq ifr2;
      ifr2 = *ifr;
		
      e = ioctl(s,SIOCGIFADDR,&ifr2);
      if ( e == -1 )
      {
         break;
      }
		
      //cerr << "ioctl addr e = " << e << endl;
		
      struct sockaddr a = ifr2.ifr_addr;
      struct sockaddr_in* addr = (struct sockaddr_in*) &a;
		
      UInt32 ai = ntohl( addr->sin_addr.s_addr );
      if (int((ai>>24)&0xFF) != 127)
      {
         addresses[count++] = ai;
      }
		
#if 0
      cerr << "Detected interface "
           << int((ai>>24)&0xFF) << "." 
           << int((ai>>16)&0xFF) << "." 
           << int((ai>> 8)&0xFF) << "." 
           << int((ai    )&0xFF) << endl;
#endif
   }
	
   closesocket(s);
	
   return count;
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xff8, %rsp            # imm = 0xFF8
movl %esi, %ebx
movq %rdi, 0x8(%rsp)
pushq $0x2
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x2080
movl %eax, %ebp
movq %rsp, (%rsp)
leaq 0x40(%rsp), %r15
movl $0xfa0, (%r15)          # imm = 0xFA0
leaq 0x50(%rsp), %r13
movq %r13, 0x8(%r15)
movl $0x8912, %esi           # imm = 0x8912
movl %eax, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2230
movl (%r15), %r14d
leaq 0x10(%rsp), %r12
xorl %r15d, %r15d
testl %r14d, %r14d
jle 0x560c
cmpl %ebx, %r15d
jge 0x560c
movq 0x20(%r13), %rax
movq %rax, 0x30(%rsp)
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x8915, %esi           # imm = 0x8915
movl %ebp, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2230
cmpl $-0x1, %eax
je 0x560c
movl 0x24(%rsp), %eax
bswapl %eax
movl %eax, %ecx
andl $0xff000000, %ecx       # imm = 0xFF000000
cmpl $0x7f000000, %ecx       # imm = 0x7F000000
je 0x5602
movslq %r15d, %rcx
incl %r15d
movq 0x8(%rsp), %rdx
movl %eax, (%rdx,%rcx,4)
addq $0x20, %r13
addl $-0x20, %r14d
jmp 0x55a1
movl %ebp, %edi
callq 0x22c0
movq (%rsp), %rsp
movl %r15d, %eax
addq $0xff8, %rsp            # imm = 0xFF8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Distrotech[P]stund/stun.cxx
// Function: stunBuildReqSimple(StunMessage*, StunAtrString const&, bool, bool, unsigned int)
void
stunBuildReqSimple( StunMessage* msg,
                    const StunAtrString& username,
                    bool changePort, bool changeIp, unsigned int id )
{
   assert( msg );
   memset( msg , 0 , sizeof(*msg) );
	
   msg->msgHdr.msgType = BindRequestMsg;
	
   for ( int i=0; i<16; i=i+4 )
   {
      assert(i+3<16);
      int r = stunRand();
      msg->msgHdr.id.octet[i+0]= r>>0;
      msg->msgHdr.id.octet[i+1]= r>>8;
      msg->msgHdr.id.octet[i+2]= r>>16;
      msg->msgHdr.id.octet[i+3]= r>>24;
   }
	
   if ( id != 0 )
   {
      msg->msgHdr.id.octet[0] = id; 
   }
	
   msg->hasChangeRequest = true;
   msg->changeRequest.value =(changeIp?ChangeIpFlag:0) | 
      (changePort?ChangePortFlag:0);
	
   if ( username.sizeValue > 0 )
   {
      msg->hasUsername = true;
      msg->username = username;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x56d8
movl %r8d, %r12d
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
movl $0x4c8, %edx            # imm = 0x4C8
xorl %esi, %esi
callq 0x2110
movw $0x1, (%r14)
cmpq $0x10, %r13
jae 0x5679
callq 0x4076
movl %eax, 0x4(%r14,%r13)
addq $0x4, %r13
jmp 0x5663
testl %r12d, %r12d
je 0x5682
movb %r12b, 0x4(%r14)
movb $0x1, 0x34(%r14)
movzbl %r15b, %eax
movzbl %bpl, %ecx
addl %ecx, %ecx
leal (%rcx,%rax,4), %eax
movl %eax, 0x38(%r14)
cmpw $0x0, 0x100(%rbx)
je 0x56c9
movb $0x1, 0x5c(%r14)
addq $0x5e, %r14
movl $0x102, %edx            # imm = 0x102
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2170
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2805(%rip), %rdi      # 0x7ee4
leaq 0x2067(%rip), %rsi      # 0x774d
leaq 0x27fb(%rip), %rcx      # 0x7ee8
movl $0x6a4, %edx            # imm = 0x6A4
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %r12
movq %rsi, 0x48(%rsp)
movq %rdx, 0x8(%rsp)
movq %rdx, %rsi
callq 0xa05a
movq %rax, %r14
cmpq %rax, 0x8(%r12)
jae 0x9f79
movq (%r12), %r15
jmp 0x9f8c
movq %r15, %rax
xorl %edx, %edx
divq %r14
movq %rax, %r15
cmpq $0x1, %rdx
sbbq $-0x1, %r15
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %r15, %rsi
callq 0xa09c
xorl %r12d, %r12d
leaq 0x50(%rsp), %r13
xorl %ebp, %ebp
subq $0x1, %r15
jb 0xa00d
leaq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
movq %r12, 0x18(%rsp)
addq %r14, %r12
cmpq 0x8(%rsp), %r12
movq %r12, 0x10(%rsp)
leaq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rax
cmovbq %rax, %rcx
movq %r13, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa0ee
movq 0x30(%rsp), %rdi
addq %rbp, %rdi
movq %r13, %rsi
callq 0xa174
movq %r13, %rdi
callq 0xa18e
addq $0x8, %rbp
jmp 0x9fa8
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %r14
cmpq %r14, %rbx
je 0xa02a
movq %rbx, %rdi
callq 0x95b0
addq $0x8, %rbx
jmp 0xa017
leaq 0x30(%rsp), %rdi
callq 0xa19c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa045
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xa19c
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x68, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %r13
movq %rsi, 0x40(%rsp)
movq %rdx, 0x8(%rsp)
movq %rdx, %rsi
callq 0xa05a
movq %rax, %r15
cmpq %rax, 0x8(%r13)
jae 0xa1fb
movq (%r13), %r12
jmp 0xa20e
movq %r12, %rax
xorl %edx, %edx
divq %r15
movq %rax, %r12
cmpq $0x1, %rdx
sbbq $-0x1, %r12
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r12, %rsi
callq 0xa09c
xorl %r13d, %r13d
leaq 0x60(%rsp), %rbp
xorl %ebx, %ebx
subq $0x1, %r12
jb 0xa299
leaq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %r14, 0x50(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
movq %r13, 0x20(%rsp)
addq %r15, %r13
cmpq 0x8(%rsp), %r13
movq %r13, 0x18(%rsp)
leaq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rax
cmovbq %rax, %rcx
movq %rbp, %rdi
leaq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xa2e6
movq 0x28(%rsp), %rdi
addq %rbx, %rdi
movq %rbp, %rsi
callq 0xa174
movq %rbp, %rdi
callq 0xa18e
addq $0x8, %rbx
jmp 0xa22a
movq 0x28(%rsp), %rbx
movq 0x30(%rsp), %r14
cmpq %r14, %rbx
je 0xa2b6
movq %rbx, %rdi
callq 0x95b0
addq $0x8, %rbx
jmp 0xa2a3
leaq 0x28(%rsp), %rdi
callq 0xa19c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa2d1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa19c
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rcx, %r15
movq %rdi, %r12
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x8(%rsp)
movq %rcx, %rsi
callq 0xa05a
movq %rax, %r14
cmpq %rax, 0x8(%r12)
jae 0xa3b2
movq (%r12), %r15
jmp 0xa3c5
movq %r15, %rax
xorl %edx, %edx
divq %r14
movq %rax, %r15
cmpq $0x1, %rdx
sbbq $-0x1, %r15
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r15, %rsi
callq 0xa09c
xorl %r12d, %r12d
leaq 0x60(%rsp), %r13
xorl %ebp, %ebp
subq $0x1, %r15
jb 0xa450
leaq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
movq %rbx, 0x58(%rsp)
movq %r12, 0x18(%rsp)
addq %r14, %r12
cmpq 0x8(%rsp), %r12
movq %r12, 0x10(%rsp)
leaq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rax
cmovbq %rax, %rcx
movq %r13, %rdi
leaq 0x48(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa49e
movq 0x20(%rsp), %rdi
addq %rbp, %rdi
movq %r13, %rsi
callq 0xa174
movq %r13, %rdi
callq 0xa18e
addq $0x8, %rbp
jmp 0xa3e1
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %r14
cmpq %r14, %rbx
je 0xa46d
movq %rbx, %rdi
callq 0x95b0
addq $0x8, %rbx
jmp 0xa45a
leaq 0x20(%rsp), %rdi
callq 0xa19c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa488
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xa19c
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x78, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r14
movq %rcx, %r12
movq %rdi, %r13
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x8(%rsp)
movq %rcx, %rsi
callq 0xa05a
movq %rax, %r15
cmpq %rax, 0x8(%r13)
jae 0xa56e
movq (%r13), %r12
jmp 0xa581
movq %r12, %rax
xorl %edx, %edx
divq %r15
movq %rax, %r12
cmpq $0x1, %rdx
sbbq $-0x1, %r12
leaq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movq %r12, %rsi
callq 0xa09c
xorl %r13d, %r13d
leaq 0x70(%rsp), %rbp
xorl %ebx, %ebx
subq $0x1, %r12
jb 0xa616
leaq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
movq %r14, 0x68(%rsp)
movq %r13, 0x20(%rsp)
addq %r15, %r13
cmpq 0x8(%rsp), %r13
movq %r13, 0x18(%rsp)
leaq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rax
cmovbq %rax, %rcx
movq %rbp, %rdi
leaq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xa664
movq 0x28(%rsp), %rdi
addq %rbx, %rdi
movq %rbp, %rsi
callq 0xa174
movq %rbp, %rdi
callq 0xa18e
addq $0x8, %rbx
jmp 0xa59d
movq 0x28(%rsp), %rbx
movq 0x30(%rsp), %r14
cmpq %r14, %rbx
je 0xa633
movq %rbx, %rdi
callq 0x95b0
addq $0x8, %rbx
jmp 0xa620
leaq 0x28(%rsp), %rdi
callq 0xa19c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa64e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa19c
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x28(%rsp)
movq %rdx, (%rsp)
movq %rcx, 0x20(%rsp)
cmpq %r8, %rdx
jne 0xa81c
movq %r12, %rdi
movq %r15, %rsi
callq 0xa05a
movq %rax, %r14
cmpq %rax, 0x8(%r12)
jae 0xa740
movq (%r12), %r15
jmp 0xa753
movq %r15, %rax
xorl %edx, %edx
divq %r14
movq %rax, %r15
cmpq $0x1, %rdx
sbbq $-0x1, %r15
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %r15, %rsi
callq 0xa09c
xorl %ebx, %ebx
leaq 0x48(%rsp), %r12
leaq 0x18(%rsp), %rbp
xorl %r13d, %r13d
subq $0x1, %r15
jb 0xa7e3
leaq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rbx, 0x18(%rsp)
addq %r14, %rbx
cmpq (%rsp), %rbx
movq %rbx, 0x10(%rsp)
movq %rsp, %rcx
leaq 0x10(%rsp), %rax
cmovbq %rax, %rcx
movq %r12, %rdi
leaq 0x30(%rsp), %rsi
movq %rbp, %rdx
callq 0xa882
movq 0x50(%rsp), %rdi
addq %r13, %rdi
movq %r12, %rsi
callq 0xa174
movq %r12, %rdi
callq 0xa18e
addq $0x8, %r13
jmp 0xa774
movq 0x50(%rsp), %rbx
movq 0x58(%rsp), %r14
cmpq %r14, %rbx
je 0xa800
movq %rbx, %rdi
callq 0x95b0
addq $0x8, %rbx
jmp 0xa7ed
leaq 0x50(%rsp), %rdi
callq 0xa19c
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x257fd(%rip), %rsi     # 0x30020
leaq 0x50(%rsp), %r14
pushq $0x3
popq %rcx
movq %r14, %rdi
movl $0x83, %edx
callq 0x2ee18
leaq 0x25802(%rip), %rsi     # 0x30041
movq %r14, %rdi
callq 0x9370
leaq 0x50(%rsp), %rdi
callq 0x2f054
jmp 0xa725
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2f054
jmp 0xa879
movq %rax, %rbx
jmp 0xa879
jmp 0xa86c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa19c
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/include/utils/ParallelOperator.h
// Function: abcdl::utils::ParallelOperator<int>::parallel_mul2mul_repeat(int*, unsigned long, int const*, unsigned long, std::function<void (int*, int const&)> const&) const
void parallel_mul2mul_repeat(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 == 0);
        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, &num_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 % num_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 $0x1e8, %rsp            # imm = 0x1E8
movq %r9, 0x10(%rsp)
movq %rdx, %r15
movq %rdi, %r12
movq %rsi, 0x50(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rdx, %rax
xorl %edx, %edx
divq %r8
testq %rdx, %rdx
jne 0xaa55
movq %r12, %rdi
movq %r15, %rsi
callq 0xa05a
movq %rax, %r14
cmpq %rax, 0x8(%r12)
jae 0xa96c
movq (%r12), %r15
jmp 0xa97f
movq %r15, %rax
xorl %edx, %edx
divq %r14
movq %rax, %r15
cmpq $0x1, %rdx
sbbq $-0x1, %r15
leaq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rdx
movq %r15, %rsi
callq 0xa09c
xorl %ebx, %ebx
leaq 0x58(%rsp), %r12
leaq 0x20(%rsp), %rbp
xorl %r13d, %r13d
subq $0x1, %r15
jb 0xaa1c
leaq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x78(%rsp)
movq %rbx, 0x20(%rsp)
addq %r14, %rbx
cmpq 0x8(%rsp), %rbx
movq %rbx, 0x18(%rsp)
leaq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rax
cmovbq %rax, %rcx
movq %r12, %rdi
leaq 0x60(%rsp), %rsi
movq %rbp, %rdx
callq 0xaaba
movq 0x28(%rsp), %rdi
addq %r13, %rdi
movq %r12, %rsi
callq 0xa174
movq %r12, %rdi
callq 0xa18e
addq $0x8, %r13
jmp 0xa9a0
movq 0x28(%rsp), %rbx
movq 0x30(%rsp), %r14
cmpq %r14, %rbx
je 0xaa39
movq %rbx, %rdi
callq 0x95b0
addq $0x8, %rbx
jmp 0xaa26
leaq 0x28(%rsp), %rdi
callq 0xa19c
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x255c4(%rip), %rsi     # 0x30020
leaq 0x60(%rsp), %r14
pushq $0x3
popq %rcx
movq %r14, %rdi
movl $0x9c, %edx
callq 0x2ee18
leaq 0x255ea(%rip), %rsi     # 0x30062
movq %r14, %rdi
callq 0x9370
leaq 0x60(%rsp), %rdi
callq 0x2f054
jmp 0xa951
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x2f054
jmp 0xaab2
movq %rax, %rbx
jmp 0xaab2
jmp 0xaaa5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa19c
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rcx, %r15
movq %rdi, %r12
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x10(%rsp)
movq %rcx, %rsi
callq 0xa05a
movq %rax, %r14
cmpq %rax, 0x8(%r12)
jae 0xadf9
movq (%r12), %r15
jmp 0xae0c
movq %r15, %rax
xorl %edx, %edx
divq %r14
movq %rax, %r15
cmpq $0x1, %rdx
sbbq $-0x1, %r15
leaq 0x30(%rsp), %rdi
leaq 0x58(%rsp), %rdx
movq %r15, %rsi
callq 0xa09c
movq %r15, %rax
shrq $0x3e, %rax
leaq (,%r15,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
xorl %r13d, %r13d
leaq 0x80(%rsp), %r12
xorl %ebp, %ebp
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0xaee0
leaq 0x48(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x8(%rsp), %rax
movq %rax, 0x68(%rsp)
movq %rbx, 0x70(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
movq %r13, 0x28(%rsp)
addq %r14, %r13
cmpq 0x10(%rsp), %r13
movq %r13, 0x20(%rsp)
leaq 0x10(%rsp), %rcx
leaq 0x20(%rsp), %rax
cmovbq %rax, %rcx
movq %r12, %rdi
leaq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xaf42
movq 0x30(%rsp), %rdi
addq %rbp, %rdi
movq %r12, %rsi
callq 0xa174
movq %r12, %rdi
callq 0xa18e
addq $0x8, %rbp
incq %rbx
jmp 0xae54
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %r14
cmpq %r14, %rbx
je 0xaefd
movq %rbx, %rdi
callq 0x95b0
addq $0x8, %rbx
jmp 0xaeea
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xaf0c
callq 0x9420
leaq 0x30(%rsp), %rdi
callq 0xa19c
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaf2c
jmp 0xaf2c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xa19c
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x4
popq %rcx
callq 0x104ec
leaq 0x3df4f(%rip), %rax     # 0x4dd08
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x178(%rbx), %r14
movq %r14, %rdi
callq 0x17dac
movq 0x50(%rsp), %r12
movq %rbp, 0x170(%rbx)
movq %r13, 0x168(%rbx)
leaq 0x30(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x14(%rsp), %r9
andl $0x0, (%r9)
leaq 0x10(%rsp), %r13
andl $0x0, (%r13)
movq %r13, (%rsp)
movq %r15, %rcx
movq %r12, %r8
callq 0x1b87e
movq 0x10(%rbx), %rdx
leaq 0x14(%rsp), %r9
andl $0x0, (%r9)
leaq 0x68(%rbx), %rdi
andl $0x0, 0x10(%rsp)
movq %r13, (%rsp)
pushq $0x1
popq %rsi
movq %r15, %rcx
movq %r12, %r8
callq 0x1b87e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfe49
movq %rax, %r15
movq %r14, %rdi
callq 0x17fd6
jmp 0xfe59
movq %rax, %r15
movq %rbx, %rdi
callq 0x105fe
movq %r15, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %r13
subq %rax, %r13
sarq $0x3, %r13
cmpq $0x2, %r13
jb 0xffb2
movq (%rax), %rcx
cmpl $0x0, 0x18(%rcx)
jne 0xffb2
leaq -0x2(%r13), %rbp
decq %r13
pushq $0x1
popq %r15
xorl %r12d, %r12d
leaq 0x20232(%rip), %r8      # 0x300ea
leaq 0x10(%rsp), %rdi
pushq $0x3a
popq %rdx
pushq $0x3
popq %rcx
movq %rax, %r9
cmpq %r12, %r13
je 0xff94
movq (%r9), %r9
movq 0x10(%r9), %rbx
movq 0x8(%rax,%r12,8), %r10
xorl %r9d, %r9d
cmpq %r12, %rbp
sete %r9b
leal (%r9,%r9,2), %r9d
incl %r9d
cmpl %r9d, 0x18(%r10)
jne 0xff04
cmpq 0x8(%r10), %rbx
jne 0xff50
leaq (%rax,%r15,8), %r9
incq %r15
incq %r12
jmp 0xfec6
movq %rsi, 0x8(%rsp)
movq %r8, %rsi
pushq $0x39
popq %rdx
callq 0x2ee18
leaq 0x10(%rsp), %rdi
leaq 0x20233(%rip), %rsi     # 0x30153
callq 0x9370
leaq 0x10(%rsp), %rdi
callq 0x2f054
movq 0x8(%rsp), %rsi
movq (%rsi), %rax
movq 0x8(%rax,%r12,8), %r10
leaq 0x201a7(%rip), %r8      # 0x300ea
leaq 0x10(%rsp), %rdi
pushq $0x3a
popq %rdx
pushq $0x3
popq %rcx
jmp 0xfef2
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq %r8, %rsi
callq 0x2ee18
movq %rbx, %rdi
leaq 0x20267(%rip), %rsi     # 0x301d1
callq 0x9370
movq %rbx, %rdi
callq 0x2f054
movq 0x8(%rsp), %rsi
movq (%rsi), %rax
leaq 0x20164(%rip), %r8      # 0x300ea
movq %rbx, %rdi
pushq $0x3a
popq %rdx
pushq $0x3
popq %rcx
jmp 0xfef8
addq $0x30, %r14
movq %r14, %rdi
callq 0x1071a
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
leaq 0x2012e(%rip), %rsi     # 0x300ea
leaq 0x10(%rsp), %r15
pushq $0x36
popq %rdx
pushq $0x3
popq %rcx
movq %r15, %rdi
callq 0x2ee18
leaq 0x20126(%rip), %rsi     # 0x300fc
movq %r15, %rdi
callq 0x9370
leaq 0x10(%rsp), %rdi
callq 0x2f054
movq %rbx, %rsi
movq (%rbx), %rax
jmp 0xfea3
jmp 0xfff7
jmp 0xfff7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2f054
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %r12
cmpq %r12, %r15
je 0x10410
movq (%r15), %rdi
testq %rdi, %rdi
je 0x10406
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, (%r15)
addq $0x8, %r15
jmp 0x103f3
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x1041e
movq %rax, 0x38(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x10432
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x48(%rbx)
leaq 0x50(%rbx), %rdi
callq 0x9160
movq %r14, %rdi
callq 0x134b0
addq $0x10, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9160
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/include/algebra/Matrix.h
// Function: abcdl::algebra::Matrix<float>::Matrix(abcdl::algebra::Matrix<float> const&)
Matrix(const Matrix<T>& mat){
        _rows = mat.rows();
        _cols = mat.cols();
        _data = new T[_rows * _cols];
        memcpy(_data, mat.data(), sizeof(T) * _rows * _cols);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0xb6e2
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %r15
movq %r15, 0x8(%r14)
imulq %rax, %r15
movq %r15, %rax
shrq $0x3e, %rax
shlq $0x2, %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
callq 0x9030
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x92c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15d
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %rsp, %r12
movq %r12, %rdi
movl $0x801, %ecx            # imm = 0x801
movq %r14, %r8
callq 0x10f68
movq (%r12), %r12
testq %r12, %r12
setne %al
movq (%r14), %r14
testq %r14, %r14
setne %bpl
andb %al, %bpl
cmpb $0x1, %bpl
jne 0x11503
testl %r15d, %r15d
setg %al
cmpl %r15d, %r14d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x114b8
movl %r15d, %r14d
movq %r14, 0x8(%rsp)
movq %r14, %rax
shrq $0x3e, %rax
leaq (,%r14,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x9030
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x114f2
movzbl 0x8(%r12,%rcx), %edx
cvtsi2ss %edx, %xmm0
movss %xmm0, (%rax,%rcx,4)
incq %rcx
jmp 0x114d9
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1823e
movq %rsp, %rdi
callq 0x111be
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x111be
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x58, %rsp
movq %r8, 0x10(%rsp)
movl %ecx, %r13d
movq %rdx, 0x28(%rsp)
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x20(%rsp), %r15
andq $0x0, (%r15)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movl $0x801, %ecx            # imm = 0x801
movq %r15, %r8
callq 0x10f68
movq (%r12), %rbp
testq %rbp, %rbp
setne %al
movq (%r15), %r14
testq %r14, %r14
setne %bl
andb %al, %bl
cmpb $0x1, %bl
jne 0x11635
testl %r13d, %r13d
setg %al
cmpl %r13d, %r14d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x115a6
movl %r13d, %r14d
movq %r14, 0x20(%rsp)
movb %bl, 0xf(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, %rax
shrq $0x3e, %rax
leaq (,%rcx,4), %r15
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r15, %rdi
callq 0x9030
movq %rax, %r12
xorl %ebx, %ebx
leaq 0x30(%rsp), %r13
cmpq %r14, %rbx
jae 0x11629
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x91e0
movzbl 0x8(%rbp,%rbx), %eax
movl $0x3f800000, (%r12,%rax,4) # imm = 0x3F800000
movq %r13, %rdi
movq %r12, %rsi
pushq $0x1
popq %rdx
movq 0x10(%rsp), %rcx
callq 0x17f08
movq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x111d8
movq %r13, %rdi
callq 0x17fd6
incq %rbx
movq 0x20(%rsp), %r14
jmp 0x115d8
movq %r12, %rdi
callq 0x9420
movb 0xf(%rsp), %bl
leaq 0x18(%rsp), %rdi
callq 0x111be
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11661
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x17fd6
jmp 0x11664
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x111be
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x20(%rsp), %r15
andq $0x0, (%r15)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movl $0x801, %ecx            # imm = 0x801
movq %r15, %r8
callq 0x10f68
movq (%r13), %r13
testq %r13, %r13
setne %al
movq (%r15), %r15
testq %r15, %r15
setne %bpl
andb %al, %bpl
cmpb $0x1, %bpl
jne 0x13859
testl %r12d, %r12d
setg %al
cmpl %r12d, %r15d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x137dd
movl %r12d, %r15d
movq %r15, 0x20(%rsp)
movq %r15, %rax
imulq %rbx, %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, %r12
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
leaq (,%rbx,4), %r14
movq %r14, %rdx
imulq %r15, %rdx
xorl %ebx, %ebx
movq %rax, %rdi
xorl %esi, %esi
callq 0x91e0
movq %r12, %rax
cmpq %rbx, %r15
je 0x13844
movzbl 0x8(%r13,%rbx), %ecx
movl $0x3f800000, (%rax,%rcx,4) # imm = 0x3F800000
incq %rbx
addq %r14, %rax
jmp 0x1382a
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x18(%rsp), %rcx
callq 0x1823e
leaq 0x8(%rsp), %rdi
callq 0x111be
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x111be
movq %rbx, %rdi
callq 0x95e0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17dac
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 0x18d80
leaq 0x20(%rbx), %r12
addq $0xf0, %r15
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rcx
movq %r12, %rsi
movq %r15, %rdx
callq 0x27db8
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x1e876
leaq 0xf0(%rbx), %r15
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x1dee2
leaq 0x30(%rsp), %rdi
callq 0x17fd6
leaq 0x8(%rsp), %rdi
callq 0x17fd6
leaq 0x58(%rsp), %rdi
callq 0x17fd6
addq $0xa0, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x18d80
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
movq %r15, %rcx
callq 0x27db8
leaq 0xc8(%rbx), %r14
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x1dee2
leaq 0x30(%rsp), %rdi
callq 0x17fd6
leaq 0x8(%rsp), %rdi
callq 0x17fd6
leaq 0x140(%rbx), %rdi
movq %r15, %rsi
callq 0x1e228
addq $0x118, %rbx            # imm = 0x118
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e228
leaq 0x80(%rsp), %rdi
callq 0x17fd6
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x17fd6
jmp 0x13afd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x13b2c
jmp 0x13b35
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x17fd6
jmp 0x13b18
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17fd6
jmp 0x13b27
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x17fd6
jmp 0x13b38
jmp 0x13b35
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x17fd6
movq %rbx, %rdi
callq 0x95e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18d80
movq %rsp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x27db8
leaq 0xc8(%rbx), %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x1dee2
movq %rsp, %rdi
callq 0x17fd6
leaq 0x28(%rsp), %rdi
callq 0x17fd6
leaq 0x118(%rbx), %rdi
movq %r15, %rsi
callq 0x1e228
addq $0x140, %rbx            # imm = 0x140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e228
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x17fd6
jmp 0x13caa
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x17fd6
movq %rbx, %rdi
callq 0x95e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x1388, %rsp           # imm = 0x1388
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x15718
movq (%rbx), %r15
decq %r15
movq %r15, %r12
subq $0x1, %r12
jb 0x1412d
movq %r14, %rdi
callq 0x9480
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)
movq %r12, %r15
jmp 0x140ff
movq %rsp, %rdi
callq 0x1576e
addq $0x1388, %rsp           # imm = 0x1388
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1576e
movq %rbx, %rdi
callq 0x95e0
nop