LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./xthread.hh
// Function: xthread::thread_create(unsigned long*, pthread_attr_t const*, void* (*)(void*), void*)
int thread_create(pthread_t * tid, const pthread_attr_t * attr, threadFunction * fn, void * arg) {
		acquireGlobalLock();
		int tindex = allocThreadIndex();
		releaseGlobalLock();

		// Acquire the thread structure.
		thread_t* children = getThread(tindex);	
		children->startArg = arg;
		children->startRoutine = fn;
		children->index = tindex;

		#ifdef CUSTOMIZED_STACK
		pthread_attr_t iattr;
		if(attr == NULL) {
			pthread_attr_init(&iattr);
		} else {
			memcpy(&iattr, attr, sizeof(pthread_attr_t));
		}
		pthread_attr_setstack(&iattr, (void*)(globalStackAddr + (intptr_t)tindex * STACK_SIZE + GUARD_PAGE_SIZE), STACK_SIZE - 2 * GUARD_PAGE_SIZE);
		/* Guard pages have already been setted before main()
		if(0 != mprotect((void*)(childrenStackStart + STACK_SIZE - GUARD_PAGE_SIZE), GUARD_PAGE_SIZE, PROT_NONE)
				|| 0 != mprotect((void*)childrenStackStart, GUARD_PAGE_SIZE, PROT_NONE)) {
			fprintf(stderr, "Failed to set guard page for thread#%d\n", tindex);
			abort();
		}
		*/

		int result = Real::pthread_create(tid, &iattr, xthread::startThread, (void *)children);
		#else
		int result = Real::pthread_create(tid, attr, xthread::startThread, (void *)children);
		#endif

		if(result) {
			FATAL("thread_create failure");
		}
		
		// Setting up this in the main thread so that
		// pthread_join can always find its pthread_t. 
		// Otherwise, it can fail because the child have set this value.
		children->pthreadt = *tid;
		acquireGlobalLock();
		_xmap.insertIfAbsent((void*)*tid, sizeof(void*), tindex);
		releaseGlobalLock();
		return result;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4240
movq %rbx, %rdi
callq 0x41b0
movl %eax, %ebp
movq %rbx, %rdi
callq 0x4090
movslq %ebp, %rax
imulq $0x1028, %rax, %rax     # imm = 0x1028
leaq (%rbx,%rax), %r15
addq $0x40, %r15
movq %r12, 0x20(%r15)
movq %r13, 0x18(%r15)
movl %ebp, 0x10(%r15)
movq 0x6b59(%rip), %rax      # 0xcf08
movq 0x6bfa(%rip), %rdx      # 0xcfb0
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rcx
callq *(%rax)
testl %eax, %eax
jne 0x640a
movq (%r14), %rax
movq %rax, 0x8(%r15)
movq %rbx, %rdi
callq 0x4240
leaq 0x8(%rbx), %rdi
movq (%r14), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movl $0x8, %edx
movl %ebp, %ecx
callq 0x40e0
movq %rbx, %rdi
callq 0x4090
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x41e0
movq %rax, %rbx
callq 0x4250
leaq 0x4491(%rip), %rdx      # 0xa8af
leaq 0x37e2(%rip), %r8       # 0x9c07
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
movq %rax, %rcx
movl $0xcb, %r9d
xorl %eax, %eax
callq 0x4490
callq 0x41e0
movq %rax, %rbx
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4370
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./xthread.hh
// Function: xthread::thread_join(unsigned long, void**)
int thread_join(pthread_t tid, void ** retval) {
		int joinretval;
		if((joinretval = Real::pthread_join(tid, retval)) == 0) {
				int joinee = -1;

				acquireGlobalLock();
				if(!_xmap.find((void *)tid, sizeof(void *), &joinee)) {
						PRERR("Cannot find joinee index for thread %p", (void *)tid);
				} else {
						_threads[joinee].available = true;
				}
				_aliveThreads--;
				releaseGlobalLock();
		}
		return joinretval;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x6b55(%rip), %rax      # 0xcfd8
movq %rsi, %rdi
movq %rdx, %rsi
callq *(%rax)
movl %eax, %ebp
testl %eax, %eax
jne 0x6540
leaq 0xc(%rsp), %r15
movl $0xffffffff, (%r15)     # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x4240
leaq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
movl $0x8, %edx
movq %r15, %rcx
callq 0x43a0
testb %al, %al
je 0x64d9
movslq 0xc(%rsp), %rax
imulq $0x1028, %rax, %rax     # imm = 0x1028
movb $0x1, 0x40(%rbx,%rax)
jmp 0x6535
callq 0x41e0
movq %rax, %r15
callq 0x4250
movq %r14, (%rsp)
leaq 0x449c(%rip), %rdx      # 0xa98d
leaq 0x370f(%rip), %r8       # 0x9c07
movl $0x1000, %esi           # imm = 0x1000
movq %r15, %rdi
movq %rax, %rcx
movl $0xf2, %r9d
xorl %eax, %eax
callq 0x4490
callq 0x41e0
movq %rax, %r14
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x40f0
decl 0x38(%rbx)
movq %rbx, %rdi
callq 0x4090
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./bibopheap.hh
// Function: BibopHeap::BibopFreeCache::getNext()
inline void * getNext() {
							if(_numFreeObjects == 0) {
									#ifdef USE_GLOBAL_FREE_CACHE
									// Repopulate from the global free cache, if possible
									if(_myGlobalFreeCache) {
											if(repopulate() == 0) {
													return NULL;
											}
									} else {
											return NULL;
									}
									#else
									return NULL;
									#endif
							}

							void ** oldTail = (void **)_tail;

							_tail += POINTER_SIZE;
							if(_tail == _endaddr) {
									// do wrap-around on _tail
									_tail = _startaddr;
							}

							_numFreeObjects--;
							if(_head == _tail) {
									PRDBG("free cache is now empty");
							}

							PRDBG("freeCache->getNext(): retval=%p, this=%p, _numFreeObjects=%lu, _capacity=%lu, _start=0x%lx, _end=0x%lx",
											*oldTail, this, _numFreeObjects, _capacity, _startaddr, _endaddr);
							return *oldTail;
					}

// Assembly:
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x67a3
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r15
leaq 0x8(%r15), %rcx
movq %rcx, 0x20(%rdi)
cmpq 0x10(%rdi), %rcx
jne 0x66c9
movq 0x8(%rbx), %rcx
movq %rcx, 0x20(%rbx)
decq %rax
movq %rax, 0x38(%rbx)
cmpq %rcx, 0x18(%rbx)
jne 0x672e
callq 0x41e0
movq %rax, %r14
callq 0x4250
leaq 0x2eaf(%rip), %rdx      # 0x9599
leaq 0x2e99(%rip), %r8       # 0x958a
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
movq %rax, %rcx
movl $0xde, %r9d
xorl %eax, %eax
callq 0x4490
callq 0x41e0
movq %rax, %r14
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x40f0
callq 0x41e0
movq %rax, %r14
callq 0x4250
leaq 0x2e8f(%rip), %rdx      # 0x95d1
leaq 0x2e41(%rip), %r8       # 0x958a
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
movq %rax, %rcx
movl $0xe2, %r9d
xorl %eax, %eax
pushq 0x10(%rbx)
pushq 0x8(%rbx)
pushq 0x28(%rbx)
pushq 0x38(%rbx)
pushq %rbx
pushq (%r15)
callq 0x4490
addq $0x30, %rsp
callq 0x41e0
movq %rax, %rbx
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40f0
movq (%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./mm.hh
// Function: MM::allocate(bool, unsigned long, int, void*)
static void* allocate(bool isShared, size_t sz, int fd, void* startaddr) {
    int protInfo = PROT_READ | PROT_WRITE;
    int sharedInfo = isShared ? MAP_SHARED : MAP_PRIVATE;
    sharedInfo |= ((fd == -1) ? MAP_ANONYMOUS : 0);
    sharedInfo |= ((startaddr != (void*)0) ? MAP_FIXED : 0);
    sharedInfo |= MAP_NORESERVE;

    void* ptr = mmap(startaddr, sz, protInfo, sharedInfo, fd, 0);
    if(ptr == MAP_FAILED) {
      FATAL("Couldn't do mmap (%s) : startaddr %p, sz %lx, protInfo=%d, sharedInfo=%d",
            strerror(errno), startaddr, sz, protInfo, sharedInfo);
    }

    return ptr;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %r8d
movq %rsi, %r14
xorl %eax, %eax
testq %rcx, %rcx
setne %al
xorl %ecx, %ecx
cmpl $-0x1, %edx
sete %cl
shll $0x5, %ecx
shll $0x4, %eax
subl %edi, %ecx
leal (%rcx,%rax), %r15d
addl $0x4002, %r15d          # imm = 0x4002
movq %rbx, %rdi
movl $0x3, %edx
movl %r15d, %ecx
xorl %r9d, %r9d
callq 0x4520
cmpq $-0x1, %rax
je 0x6e30
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x41e0
movq %rax, %r12
callq 0x4250
movq %rax, %r13
callq 0x4030
movl (%rax), %edi
callq 0x40d0
movq %rax, %r10
subq $0x8, %rsp
leaq 0x2a7e(%rip), %rdx      # 0x98d8
leaq 0x2aeb(%rip), %r8       # 0x994c
movl $0x1000, %esi           # imm = 0x1000
movq %r12, %rdi
movq %r13, %rcx
movl $0x3c, %r9d
xorl %eax, %eax
pushq %r15
pushq $0x3
pushq %r14
pushq %rbx
pushq %r10
callq 0x4490
addq $0x30, %rsp
callq 0x41e0
movq %rax, %rbx
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4370
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./xthread.hh
// Function: xthread::initializeInitialThread()
void initializeInitialThread(void) {
		int tindex = allocThreadIndex();
   	assert(tindex == 0);

		thread_t * thread = getThread(tindex);
	
		// Initial myself, like threadIndex, tid
		initializeCurrentThread(thread);
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x41b0
testl %eax, %eax
jne 0x6ed0
leaq 0x40(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x4060
leaq 0x2d24(%rip), %rdi      # 0x9bfb
leaq 0x2d29(%rip), %rsi      # 0x9c07
leaq 0x2d2f(%rip), %rcx      # 0x9c14
movl $0x57, %edx
callq 0x4200
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./hashmap.hh
// Function: HashMap<void*, int, HeapAllocator>::initialize(unsigned long (*)(void*, unsigned long), bool (*)(void*, void*, unsigned long), unsigned long)
void initialize(hashFuncPtr hfunc, keycmpFuncPtr kcmp, const size_t size = 4096) {
    _entries = NULL;
    _bucketsUsed = 0;
    _buckets = size;

    if(hfunc == NULL || kcmp == NULL) {
      //PRINF("Hashfunc or kcmp should not be null\n");
      abort();
    }

    // Initialize those functions.
    _hashfunc = hfunc;
    _keycmp = kcmp;

    // Allocated predefined size.
    _entries = (struct HashEntry*)SourceHeap::allocate(size * sizeof(struct HashEntry));
    //    PRINF("hashmap initialization at %p pid %d index %d\n", &_initialized,getpid(),
    // getThreadIndex());
    //    PRINF("hashmap initialization _entries %p\n", _entries);

    // Initialize all of these _entries.
    struct HashEntry* entry;
    for(size_t i = 0; i < size; i++) {
      entry = getHashEntry(i);
      entry->initialize();
    }
    _initialized = true;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq %rax, 0x18(%rdi)
movq %rcx, 0x10(%rdi)
testq %rsi, %rsi
je 0x6f77
testq %rdx, %rdx
je 0x6f77
movq %rcx, %rbx
movq %rdi, %r14
movq %rsi, 0x28(%rdi)
movq %rdx, 0x20(%rdi)
leaq (,%rcx,8), %rax
leaq (%rax,%rax,2), %rdi
movq 0x5ffb(%rip), %rax      # 0xcf28
callq *(%rax)
movq %rax, 0x8(%r14)
testq %rbx, %rbx
je 0x6f6b
movq 0x10(%r14), %rax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movq 0x8(%r14), %rdi
addq %rdx, %rdi
cmpq %rsi, %rax
cmovbeq %rcx, %rdi
movq $0x0, 0x10(%rdi)
movq %rdi, (%rdi)
movq %rdi, 0x8(%rdi)
incq %rsi
addq $0x18, %rdx
cmpq %rsi, %rbx
jne 0x6f42
movb $0x1, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4170
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./hashmap.hh
// Function: HashMap<void*, int, HeapAllocator>::insert(void* const&, unsigned long, int)
void insert(const KeyType& key, size_t keylen, ValueType value) {
    if(_initialized != true) {
      //PRINT("process %d index %d: initialized at  %p hashmap is not true\n", getpid(),
      //      getThreadIndex(), &_initialized);
    }

    assert(_initialized == true);
    size_t hindex = hashIndex(key, keylen);
    // PRINF("Insert entry:  before inserting\n");
    struct HashEntry* first = getHashEntry(hindex);

    // PRINF("Insert entry: key %p\n", key);
    insertEntry(first, key, keylen, value);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
je 0x704b
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rdi
movq %rdx, %rsi
callq *0x28(%r12)
xorl %edx, %edx
divq 0x10(%r12)
movq 0x8(%r12), %rax
leaq (%rdx,%rdx,2), %rcx
leaq (%rax,%rcx,8), %r12
movq 0x5f1c(%rip), %rax      # 0xcf28
movl $0x28, %edi
callq *(%rax)
movq (%r15), %rcx
movq %rax, (%rax)
movq %rcx, 0x10(%rax)
movslq %r14d, %rcx
movq %rcx, 0x18(%rax)
movl %ebx, 0x20(%rax)
movq (%r12), %rcx
movq %r12, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
movq %rax, (%r12)
incq 0x10(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2c42(%rip), %rdi      # 0x9c94
leaq 0x2c50(%rip), %rsi      # 0x9ca9
leaq 0x2c56(%rip), %rcx      # 0x9cb6
movl $0x9f, %edx
callq 0x4200
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./xthread.hh
// Function: xthread::allocThreadIndex()
int allocThreadIndex() {
    int index = -1;

		if(_aliveThreads == MAX_ALIVE_THREADS) {
				FATAL("maximum concurrent thread limit reached (%d)", MAX_ALIVE_THREADS);
		}

    thread_t* thread;
		if(_aliveThreads++ == _threadIndex) {
			index = _threadIndex++;
      thread = getThread(index);
			thread->available = false;
		} else {
			for(int i = 0; i <= _threadIndex; i++) {
      	thread = getThread(i);
      	if(thread->available) {
        	thread->available = false;
					index = i;
					break;
				}
			}
		}
    return index;
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movslq 0x38(%rdi), %rax
cmpq $0x80, %rax
je 0x70ce
leal 0x1(%rax), %edx
movl %edx, 0x38(%rdi)
movl 0x4(%rdi), %ecx
cmpl %ecx, %eax
jne 0x709b
movl %edx, 0x4(%rdi)
imulq $0x1028, %rax, %rcx     # imm = 0x1028
addq %rcx, %rdi
addq $0x40, %rdi
jmp 0x70c5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
js 0x70c8
addq $0x40, %rdi
incq %rcx
xorl %edx, %edx
cmpb $0x1, (%rdi)
je 0x70c3
incq %rdx
addq $0x1028, %rdi           # imm = 0x1028
cmpq %rdx, %rcx
jne 0x70ad
jmp 0x70c8
movl %edx, %eax
movb $0x0, (%rdi)
addq $0x10, %rsp
popq %rbx
retq
callq 0x41e0
movq %rax, %rbx
callq 0x4250
movl $0x80, (%rsp)
leaq 0x2b53(%rip), %rdx      # 0x9c3c
leaq 0x2b17(%rip), %r8       # 0x9c07
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
movq %rax, %rcx
movl $0x90, %r9d
xorl %eax, %eax
callq 0x4490
callq 0x41e0
movq %rax, %rbx
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4370
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./bibopheap.hh
// Function: BibopHeap::BibopObjCache::malloc()
void * malloc() {
					// TODO: change how this repopulation threshold is calculated
					// Ex: cache size = 256, half cache size = 128, bag size = 32MB (yes, very small);
					// only 64 objects exist in each 512KB class; thus, we would never reach the cache
					// allowance of used objects until something bad has happened (segfault, doubly-
					// allocated objects, etc.)   -- SAS
					if(_numUsedObjects > BIBOP_HALF_CACHE_SIZE) {
							// Pull in free objects from the free cache
							//PRDBG("out of objects in the cache; need to repopulate from free cache");
							repopulate();
					}

					//#pragma message "doReplacement turned off"
					//bool doReplacement = false;
					bool doReplacement = true;
					uintptr_t object = getRandomObject(doReplacement);

    			#ifdef USE_CANARY
					// We must install the canary prior to marking the object as in-use,
					// otherwise another thread performing neighbor checking could
					// identify the object as in-use, but will raise a false alarm
					// due to the missing canary value.
					char * canary = (char *)object + _classSize - 1;
					*canary = CANARY_SENTINEL;
    			#endif

					// Mark the object as in-use in the shadow memory
					if(!markObjectUsed(object)) {
							FATAL("object 0x%lx already set as in-use", object);
					}

					PRDBG("...returning object 0x%lx", object);
					return (void *)object;
			}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x5d02(%rip), %rax      # 0xcf20
movl 0x8(%rax), %eax
shrl %eax
cmpl %eax, 0x2c(%rdi)
jbe 0x7230
movq %r14, %rdi
callq 0x43e0
movq %r14, %rdi
movl $0x1, %esi
callq 0x44e0
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x4420
movl %eax, %ebp
callq 0x41e0
movq %rax, %r14
callq 0x4250
testb %bpl, %bpl
je 0x72ba
movq %rbx, (%rsp)
leaq 0x2b98(%rip), %rdx      # 0x9e02
leaq 0x2319(%rip), %r8       # 0x958a
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
movq %rax, %rcx
movl $0x1ae, %r9d            # imm = 0x1AE
xorl %eax, %eax
callq 0x4490
callq 0x41e0
movq %rax, %r14
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x40f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, (%rsp)
leaq 0x2aef(%rip), %rdx      # 0x9db4
leaq 0x22be(%rip), %r8       # 0x958a
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
movq %rax, %rcx
movl $0x1ab, %r9d            # imm = 0x1AB
xorl %eax, %eax
callq 0x4490
callq 0x41e0
movq %rax, %rbx
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4370
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./bibopheap.hh
// Function: BibopHeap::BibopObjCache::markObjectUsed(unsigned long)
bool markObjectUsed(uintptr_t object) {
					shadowObjectInfo * shadowMemAddr = BibopHeap::getInstance().getShadowObjectInfo((void *)object);
					shadowObjectInfo oldSmValue = *shadowMemAddr;
					*shadowMemAddr = ALLOC_SENTINEL;

					return (oldSmValue == FREE_SENTINEL);
			}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x4100
subq (%rax), %rbx
movq 0x54b1(%rip), %rcx      # 0xcfe8
movq (%rcx), %rdx
andq %rbx, %rdx
movq 0x5424(%rip), %rcx      # 0xcf68
movb (%rcx), %cl
movq %rbx, %rsi
shrq %cl, %rsi
movb 0x38(%rax), %cl
shrq %cl, %rbx
andq 0x40(%rax), %rsi
shlq $0xb, %rbx
addq %rax, %rbx
shlq $0x7, %rsi
movb 0x19b0(%rsi,%rbx), %cl
shrq %cl, %rdx
movq 0x19c0(%rsi,%rbx), %rax
cmpb $0x0, (%rax,%rdx)
movb $0x1, (%rax,%rdx)
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./bibopheap.hh
// Function: BibopHeap::BibopObjCache::initialPopulate()
void initialPopulate() {
					unsigned i;

					// Initialize each of the cache region object
					// counters to indicate a full buffer
					for(i = 0; i < NUM_CACHE_REGIONS; i++) {
							_regionCounters[i] = CACHE_REGION_SIZE;
					}

					// Initialize the cache with new objects from top of current subheap
					for(i = 0; i < BibopHeap::_cacheSize; i++) {
							_objects[i] = getNext();

							assert(_objects[i] != NULL);
					}

					// If we decide to place the object cache in mmap'd memory rather than
					// global memory we MUST ensure that unused entries are initialized to
					// zero
					for(i = BibopHeap::_cacheSize; i < BibopHeap::_cacheSize; i++) {
							_objects[i] = NULL;
					}
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x5394(%rip), %rax      # 0xcf20
movd 0x8(%rax), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
psrld $0x3, %xmm0
movdqu %xmm0, 0x34(%rdi)
movdqu %xmm0, 0x44(%rdi)
movq 0x53c4(%rip), %r14      # 0xcf70
cmpl $0x0, (%r14)
je 0x7bde
movq %rdi, %rbx
xorl %r15d, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x58(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x58(%rbx), %rax
cmpq $0x0, (%rax,%r15,8)
je 0x7be4
incq %r15
movl (%r14), %eax
cmpq %rax, %r15
jb 0x7bb8
popq %rbx
popq %r14
popq %r15
retq
leaq 0x274c(%rip), %rdi      # 0xa337
leaq 0x1998(%rip), %rsi      # 0x958a
leaq 0x2752(%rip), %rcx      # 0xa34b
movl $0x1c1, %edx            # imm = 0x1C1
callq 0x4200
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./hashmap.hh
// Function: HashMap<void*, BigHeap::bigObjectStatus*, HeapAllocator>::find(void* const&, unsigned long, BigHeap::bigObjectStatus**)
bool find(const KeyType& key, size_t keylen, ValueType* value) {
    assert(_initialized == true);
    size_t hindex = hashIndex(key, keylen);
    struct HashEntry* first = getHashEntry(hindex);
    struct Entry* entry = getEntry(first, key, keylen);
    bool isFound = false;

    if(entry) {
      *value = entry->value;
      isFound = true;
    }

    return isFound;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
je 0x7e3f
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rdi
movq %rdx, %rsi
callq *0x28(%r12)
xorl %ecx, %ecx
xorl %edx, %edx
divq 0x10(%r12)
movq 0x8(%r12), %rax
leaq (%rdx,%rdx,2), %rdx
movl 0x10(%rax,%rdx,8), %ebp
testl %ebp, %ebp
jle 0x7e2e
leaq (%rax,%rdx,8), %r13
incl %ebp
movq 0x8(%r13), %r13
cmpq %r14, 0x18(%r13)
jne 0x7e1a
movq 0x10(%r13), %rdi
movq (%r15), %rsi
movq %r14, %rdx
callq *0x20(%r12)
testb %al, %al
jne 0x7e25
decl %ebp
cmpl $0x1, %ebp
jg 0x7dfd
xorl %ecx, %ecx
jmp 0x7e2e
movq 0x20(%r13), %rax
movq %rax, (%rbx)
movb $0x1, %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e4e(%rip), %rdi      # 0x9c94
leaq 0x1e5c(%rip), %rsi      # 0x9ca9
leaq 0x2729(%rip), %rcx      # 0xa57d
movl $0x8b, %edx
callq 0x4200
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./hashmap.hh
// Function: HashMap<void*, BigHeap::bigObjectStatus*, HeapAllocator>::erase(void* const&, unsigned long)
bool erase(const KeyType& key, size_t keylen) {
    assert(_initialized == true);
    size_t hindex = hashIndex(key, keylen);
    struct HashEntry* first = getHashEntry(hindex);
    struct Entry* entry;
    bool isFound = false;

    entry = getEntry(first, key, keylen);

    //    PRINF("Erapse the entry key %p entry %p\n", key, entry);
    if(entry) {
      isFound = true;

      // Check whether this entry is the first entry.
      // Remove this entry if existing.
      entry->erase();

      SourceHeap::deallocate(entry);
    }

    first->count--;

    return isFound;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
je 0x7f0c
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rdi
movq %rdx, %rsi
callq *0x28(%r15)
xorl %ecx, %ecx
xorl %edx, %edx
divq 0x10(%r15)
movq 0x8(%r15), %rax
leaq (%rdx,%rdx,2), %rdx
leaq (%rax,%rdx,8), %r13
movl 0x10(%r13), %ebp
testl %ebp, %ebp
jle 0x7ef7
incl %ebp
movq %r13, %r12
movq 0x8(%r12), %r12
cmpq %rbx, 0x18(%r12)
jne 0x7ec5
movq 0x10(%r12), %rdi
movq (%r14), %rsi
movq %rbx, %rdx
callq *0x20(%r15)
testb %al, %al
jne 0x7ed0
decl %ebp
cmpl $0x1, %ebp
jg 0x7ea6
xorl %ecx, %ecx
jmp 0x7ef7
movq (%r12), %rax
movq 0x8(%r12), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq %r12, (%r12)
movq %r12, 0x8(%r12)
movq 0x50c8(%rip), %rax      # 0xcfb8
movq %r12, %rdi
callq *(%rax)
movb $0x1, %cl
decq 0x10(%r13)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d81(%rip), %rdi      # 0x9c94
leaq 0x1d8f(%rip), %rsi      # 0x9ca9
leaq 0x2752(%rip), %rcx      # 0xa673
movl $0xbd, %edx
callq 0x4200
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./xthread.hh
// Function: xthread::startThread(void*)
static void * startThread(void * arg) {
    thread_t * current = (thread_t *) arg;

    xthread::getInstance().initializeCurrentThread(current);

		// Actually run this thread using the function call
    void * result = NULL;
    try{
      result = current->startRoutine(current->startArg);
    }
    catch (int err){
      if(err != PTHREADEXIT_CODE){
        throw err;
      }
    }

 	  return result;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4210
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4060
movq 0x20(%rbx), %rdi
callq *0x18(%rbx)
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x802f
movq %rbx, %rdi
callq 0x4110
movl (%rax), %ebx
cmpl $0x8b6, %ebx            # imm = 0x8B6
jne 0x800a
callq 0x44c0
xorl %eax, %eax
jmp 0x7fe5
movl $0x4, %edi
callq 0x4140
movl %ebx, (%rax)
movq 0x4ec3(%rip), %rsi      # 0xcee0
movq %rax, %rdi
xorl %edx, %edx
callq 0x4500
movq %rax, %rbx
callq 0x44c0
movq %rbx, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./hashmap.hh
// Function: HashMap<void*, int, HeapAllocator>::insertIfAbsent(void* const&, unsigned long, int)
bool insertIfAbsent(const KeyType& key, size_t keylen, ValueType value) {
    assert(_initialized == true);
    size_t hindex = hashIndex(key, keylen);
    struct HashEntry* first = getHashEntry(hindex);
    struct Entry* entry;
    bool isFound = true;

    // Check all _entries with the same hindex.
    entry = getEntry(first, key, keylen);
    if(!entry) {
      isFound = false;
      insertEntry(first, key, keylen, value);
    }

    return isFound;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
cmpb $0x0, (%rdi)
je 0x80f8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rdi
movq %rdx, %rsi
callq *0x28(%r12)
xorl %edx, %edx
divq 0x10(%r12)
movq 0x8(%r12), %rax
leaq (%rdx,%rdx,2), %rcx
leaq (%rax,%rcx,8), %rbx
movl 0x10(%rbx), %ebp
testl %ebp, %ebp
jle 0x80a8
incl %ebp
movq %rbx, %r13
movq 0x8(%r13), %r13
cmpq %r14, 0x18(%r13)
jne 0x80a1
movq 0x10(%r13), %rdi
movq (%r15), %rsi
movq %r14, %rdx
callq *0x20(%r12)
testb %al, %al
jne 0x80e7
decl %ebp
cmpl $0x1, %ebp
jg 0x8084
movq 0x4e79(%rip), %rax      # 0xcf28
movl $0x28, %edi
callq *(%rax)
movq (%r15), %rcx
movq %rax, (%rax)
movq %rcx, 0x10(%rax)
movslq %r14d, %rcx
movq %rcx, 0x18(%rax)
movl 0x4(%rsp), %ecx
movl %ecx, 0x20(%rax)
movq (%rbx), %rcx
movq %rbx, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
movq %rax, (%rbx)
incq 0x10(%rbx)
xorl %eax, %eax
jmp 0x80e9
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b95(%rip), %rdi      # 0x9c94
leaq 0x1ba3(%rip), %rsi      # 0x9ca9
leaq 0x27e3(%rip), %rcx      # 0xa8f0
movl $0xab, %edx
callq 0x4200
nop
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/TextQuery.cc
// Function: TextQuery::cleanup_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string TextQuery::cleanup_str(const string& word)
{
    string ret;
    for (auto it = word.begin(); it != word.end(); ++it) {
        if (!ispunct(*it))
            ret += tolower(*it);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, -0x30(%rbp)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r12
testq %r12, %r12
je 0x51f0
movq %rsi, %r14
movq (%rsi), %rbx
movq %rbx, %r13
movsbl (%r13), %r15d
movl %r15d, %edi
callq 0x3330
testl %eax, %eax
jne 0x51e4
movl %r15d, %edi
callq 0x3280
movsbl %al, %esi
movq -0x30(%rbp), %rdi
callq 0x31a0
movq (%r14), %rbx
movq 0x8(%r14), %r12
incq %r13
leaq (%rbx,%r12), %rax
cmpq %rax, %r13
jne 0x51b8
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0x5222
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x31e0
movq %r14, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/TextQuery.cc
// Function: TextQuery::display_map()
void TextQuery::display_map()
{
    auto iter = wm.cbegin(), iter_end = wm.cend();

    // for each word in the map
    for ( ; iter != iter_end; ++iter) {
        cout << "word: " << iter->first << " {";

        // fetch location vector as a const reference to avoid copying it
        auto text_locs = iter->second;
        auto loc_iter = text_locs->cbegin(),
                        loc_iter_end = text_locs->cend();

        // print all line numbers for this word
        while (loc_iter != loc_iter_end)
        {
            cout << *loc_iter;

            if (++loc_iter != loc_iter_end)
                 cout << ", ";

         }

         cout << "}\n";  // end list of output this word
    }
    cout << endl;  // finished printing entire map
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x28(%rdi), %r14
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
cmpq %rdi, %r14
je 0x58e7
movq 0x47c1(%rip), %r15      # 0x9fc8
leaq 0x19c7(%rip), %r13      # 0x71d5
movl $0x6, %edx
movq %r15, %rdi
leaq 0x19ae(%rip), %rsi      # 0x71cb
callq 0x3220
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x3220
movl $0x2, %edx
movq %rax, %rdi
leaq 0x1991(%rip), %rsi      # 0x71d2
callq 0x3220
movq 0x40(%r14), %r12
movq 0x48(%r14), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x5874
movq 0x4762(%rip), %rax      # 0x9fc0
cmpb $0x0, (%rax)
je 0x586c
movq -0x30(%rbp), %rax
incl 0x8(%rax)
jmp 0x5874
movq -0x30(%rbp), %rax
lock
incl 0x8(%rax)
movq 0x18(%r12), %rbx
addq $0x8, %r12
cmpq %r12, %rbx
je 0x58b0
movq 0x20(%rbx), %rsi
movq %r15, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3230
cmpq %r12, %rax
je 0x58b0
movq %rax, %rbx
movl $0x2, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x3220
jmp 0x5882
movl $0x2, %edx
movq %r15, %rdi
leaq 0x1919(%rip), %rsi      # 0x71d8
callq 0x3220
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x58d2
callq 0x441a
movq %r14, %rdi
callq 0x3230
movq %rax, %r14
cmpq -0x38(%rbp), %rax
jne 0x580e
movq 0x46da(%rip), %rbx      # 0x9fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3140
jmp 0x5925
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x5936
callq 0x441a
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/get_print.cc
// Function: get_file(int, char**)
TextQuery get_file(int argc, char **argv)
{
    // get a file to read from which user will query words
	ifstream infile;
	if (argc == 2)
    	infile.open(argv[1]);
    if (!infile) {
        throw runtime_error("No input file!");
    }

    return TextQuery(infile);  // builds query map
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x220(%rbp), %rdi
callq 0x3210
cmpl $0x2, %r15d
jne 0x64d0
movq 0x8(%r14), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x3100
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x200(%rbp,%rax)
jne 0x6511
leaq -0x220(%rbp), %rsi
movq %rbx, %rdi
callq 0x4eb8
leaq -0x220(%rbp), %rdi
callq 0x3060
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x30e0
movq %rax, %rbx
leaq 0xd97(%rip), %rsi       # 0x72bc
movq %rax, %rdi
callq 0x30c0
movq 0x3abc(%rip), %rsi      # 0x9ff0
movq 0x3a7d(%rip), %rdx      # 0x9fb8
movq %rbx, %rdi
callq 0x32d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
jmp 0x6553
movq %rax, %r14
leaq -0x220(%rbp), %rdi
callq 0x3060
movq %r14, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/get_print.cc
// Function: get_word(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool get_word(string &s1)
{
    cout << "enter a word to search for, or q to quit: ";
    cin >> s1;
    if (!cin || s1 == "q") return false;
    else return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3a50(%rip), %rdi      # 0x9fc8
leaq 0xd4c(%rip), %rsi       # 0x72cb
movl $0x2a, %edx
callq 0x3220
movq 0x3a48(%rip), %r14      # 0x9fd8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3250
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x65ae
xorl %eax, %eax
jmp 0x65c2
leaq 0xd41(%rip), %rsi       # 0x72f6
movq %rbx, %rdi
callq 0x3080
testl %eax, %eax
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/get_print.cc
// Function: get_words(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool get_words(string &s1, string &s2)
{

    // iterate with the user: prompt for a word to find and print results
    cout << "enter two words to search for, or q to quit: ";
    cin  >> s1;

    // stop if hit eof on input or a "q" is entered
    if (!cin || s1 == "q") return false;
    cin >> s2;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x39ea(%rip), %rdi      # 0x9fc8
leaq 0xd13(%rip), %rsi       # 0x72f8
movl $0x2d, %edx
callq 0x3220
movq 0x39e2(%rip), %r15      # 0x9fd8
movq %r15, %rdi
movq %r14, %rsi
callq 0x3250
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
je 0x6614
xorl %eax, %eax
jmp 0x6638
leaq 0xcdb(%rip), %rsi       # 0x72f6
movq %r14, %rdi
callq 0x3080
testl %eax, %eax
je 0x6610
movq 0x39aa(%rip), %rdi      # 0x9fd8
movq %rbx, %rsi
callq 0x3250
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/integeruser[P]GA3C-cpp/src/ga3c.cc
// Function: select_action(std::shared_ptr<Environment>, float, std::vector<float, std::allocator<float>> const&)
action_t select_action(std::shared_ptr<Environment> env, float epsilon, const std::vector<float>& policy)
{
    const bool should_explore = std::uniform_real_distribution<float>(0.0f, 1.0f)(random_engine) < epsilon;
    if (should_explore) {
        // perform a random action
        return env->sample();
    }
    else {
        // perform an action according to the current policy
        return std::discrete_distribution<action_t>(policy.cbegin(), policy.cend())(random_engine);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movss %xmm0, 0x4(%rsp)
movq %rdi, %r14
leaq 0x8fb2(%rip), %rdi      # 0xb5e8
callq 0x438b
movss 0x4(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x2656
movq (%r14), %rdi
movq (%rdi), %rax
addq $0x38, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x44ce
leaq 0x8f77(%rip), %rsi      # 0xb5e8
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x48f6
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2696
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x26ad
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3662
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/integeruser[P]GA3C-cpp/src/ga3c.cc
// Function: trainer()
void trainer()
{
    while (num_training_experiences < MAX_NUM_TRAINING_EXPERIENCES) {
        const auto batch_size = std::min(BATCH_SIZE, MAX_NUM_TRAINING_EXPERIENCES-num_training_experiences);

        auto batch = std::vector<training_experience_t>(batch_size);
        for (uint32_t i = 0; i < batch.size(); ++i) {
            batch[i] = training_experiences_queue.pop();
        }
        fit(batch);
        num_training_experiences += batch_size;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x6fb7(%rip), %eax      # 0xa258
leaq 0x6ee4(%rip), %rcx      # 0xa18c
movl (%rcx), %ebx
cmpl %ebx, %eax
jae 0x33ee
leaq 0x30(%rsp), %rbp
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %r15
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
subl %eax, %ebx
cmpl $0x20, %ebx
movl $0x20, %eax
cmovael %eax, %ebx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x397c
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x33bc
movl $0x1, %r14d
xorl %r12d, %r12d
movq %r15, %rdi
leaq 0x6ea7(%rip), %rsi      # 0xa1b0
callq 0x3a06
movq 0x8(%rsp), %rax
leaq (%r12,%r12,4), %rcx
leaq (%rax,%rcx,8), %r12
movq 0x10(%r12), %rdi
movq 0x20(%r12), %rsi
movups 0x30(%rsp), %xmm0
movups %xmm0, 0x10(%r12)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movq $0x0, 0x10(%rbp)
testq %rdi, %rdi
je 0x3385
subq %rdi, %rsi
callq 0x21c0
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdi
movq %rax, 0x8(%r12)
movss 0x20(%rsp), %xmm0
movss %xmm0, (%r12)
testq %rdi, %rdi
je 0x339b
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
jmp 0x339b
movq 0x28(%rsp), %rax
movq %rax, 0x8(%r12)
movss 0x20(%rsp), %xmm0
movss %xmm0, (%r12)
movl %r14d, %r12d
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
sarq $0x3, %rax
imulq %r13, %rax
incl %r14d
cmpq %r12, %rax
ja 0x32ff
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x30bc
addl %ebx, 0x6e89(%rip)      # 0xa258
movq %r14, %rdi
callq 0x3aca
movl 0x6e7b(%rip), %eax      # 0xa258
leaq 0x6da8(%rip), %rcx      # 0xa18c
movl (%rcx), %ebx
cmpl %ebx, %eax
jb 0x32cb
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33ff
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3aca
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/integeruser[P]GA3C-cpp/src/ga3c.cc
// Function: train(std::shared_ptr<Model>, std::vector<std::shared_ptr<Environment>, std::allocator<std::shared_ptr<Environment>>> const&)
void train(std::shared_ptr<Model> model, const std::vector<std::shared_ptr<Environment>>& environments)
{
    assert(BATCH_SIZE >= 0);

    assert(N_STEP_RETURN >= 1);
    assert(GAMMA >= 0.0f and GAMMA <= 1.0f);

    assert(EPSILON_START >= 0.0f and EPSILON_START <= 1.0f);
    assert(EPSILON_END   >= 0.0f and EPSILON_END   <= 1.0f and EPSILON_END <= EPSILON_START);

    assert(NUM_AGENTS >= 0);
    assert(MAX_NUM_TRAINING_EXPERIENCES >= 0);

    shared_model = model;
    assert(environments.size() == NUM_AGENTS);

    // start the trainer and the agents
    auto trainer_thread = std::thread(trainer);
    auto agents_threads = std::vector<std::thread>(NUM_AGENTS);
    for (uint32_t id = 0; id < NUM_AGENTS; ++id) {
        agents_threads[id] = std::thread(agent, id, environments[id]);
    }

    // and wait for them to finish
    for (uint32_t id = 0; id < NUM_AGENTS; ++id) {
        agents_threads[id].join();
    }
    trainer_thread.join();
    assert(num_training_experiences == MAX_NUM_TRAINING_EXPERIENCES);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
movq %rax, 0x6d72(%rip)      # 0xa1a0
leaq 0x8(%rdi), %rsi
leaq 0x6d6f(%rip), %rdi      # 0xa1a8
callq 0x4342
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x4, %rax
leaq 0x6d38(%rip), %r13      # 0xa188
movl (%r13), %ecx
cmpq %rcx, %rax
jne 0x3546
leaq -0x1d7(%rip), %rsi      # 0x328d
leaq 0x8(%rsp), %rdi
callq 0x3b1e
movl (%r13), %esi
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3b88
movl $0x0, 0x4(%rsp)
cmpl $0x0, (%r13)
je 0x350b
xorl %eax, %eax
leaq -0xaf7(%rip), %r14      # 0x29a2
leaq 0x10(%rsp), %r15
leaq 0x4(%rsp), %r12
movl %eax, %ecx
shlq $0x4, %rcx
addq (%rbx), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3bf6
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpq $0x0, (%rcx,%rax,8)
jne 0x35aa
movq 0x10(%rsp), %rdx
movq %rdx, (%rcx,%rax,8)
incl %eax
movl %eax, 0x4(%rsp)
movl (%r13), %ecx
cmpl %ecx, %eax
jb 0x34a3
testl %ecx, %ecx
je 0x350b
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x18(%rsp), %rdi
addq %rbx, %rdi
callq 0x2290
incq %r14
movl (%r13), %eax
addq $0x8, %rbx
cmpq %rax, %r14
jb 0x34ee
leaq 0x8(%rsp), %rdi
callq 0x2290
movl 0x6d3d(%rip), %eax      # 0xa258
leaq 0x6c6a(%rip), %rcx      # 0xa18c
cmpl (%rcx), %eax
jne 0x3565
leaq 0x18(%rsp), %rdi
callq 0x3ca0
cmpq $0x0, 0x8(%rsp)
jne 0x35aa
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2be3(%rip), %rdi      # 0x6130
leaq 0x2b1f(%rip), %rsi      # 0x6073
leaq 0x2b7f(%rip), %rcx      # 0x60da
movl $0xb7, %edx
callq 0x20d0
leaq 0x2be6(%rip), %rdi      # 0x6152
leaq 0x2b00(%rip), %rsi      # 0x6073
leaq 0x2b60(%rip), %rcx      # 0x60da
movl $0xc5, %edx
callq 0x20d0
jmp 0x358d
movq %rax, %rbx
jmp 0x359a
jmp 0x358d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3ca0
cmpq $0x0, 0x8(%rsp)
jne 0x35aa
movq %rbx, %rdi
callq 0x22b0
callq 0x2040
nop
// File: /workspace/github_cpp_makefile_star2_O3/integeruser[P]GA3C-cpp/include/queue.h
// Function: Queue<std::tuple<std::vector<float, std::allocator<float>>, long, float>>::pop()
T pop()
        {
            std::unique_lock<std::mutex> lock(this->mutex);
            this->condition.wait(lock, [=] { return !this->queue.empty(); });
            T rc(std::move(this->queue.back()));
            this->queue.pop_back();
            return rc;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x4fca
movb $0x1, 0x8(%r15)
movq 0x88(%r14), %rax
cmpq 0x68(%r14), %rax
jne 0x3a5f
leaq 0x28(%r14), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2050
movq 0x88(%r14), %rax
cmpq 0x68(%r14), %rax
je 0x3a47
cmpq 0x90(%r14), %rax
jne 0x3a78
movq 0xa0(%r14), %rcx
movl $0x1e0, %eax            # imm = 0x1E0
addq -0x8(%rcx), %rax
addq $0x58, %r14
movl -0x28(%rax), %ecx
movl %ecx, (%rbx)
movq -0x20(%rax), %rcx
movq %rcx, 0x8(%rbx)
movups -0x18(%rax), %xmm0
movups %xmm0, 0x10(%rbx)
movq -0x8(%rax), %rcx
movq %rcx, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, -0x18(%rax)
movq $0x0, -0x8(%rax)
movq %r14, %rdi
callq 0x5718
leaq 0x8(%rsp), %rdi
callq 0x4fb4
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/integeruser[P]GA3C-cpp/src/main.cc
// Function: main
int main(int argc, char const *argv[])
{
    const auto start = std::chrono::steady_clock::now();

    // train the model
    auto model = std::make_shared<Model>();
    std::vector<std::shared_ptr<Environment>> environments;
    for (uint32_t id = 0; id < NUM_AGENTS; ++id) {
        auto env = std::make_shared<Environment>();
        environments.push_back(env);
    }
    train(model, environments);

    const auto end = std::chrono::steady_clock::now();
    const std::chrono::duration<float> duration_s = end-start;
    std::cout << "Training finished in " << duration_s.count() << " seconds" << std::endl;

    // save the trained model
    model->save();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
callq 0x21e0
movq %rax, 0x48(%rsp)
movl $0x18, %edi
callq 0x21b0
movq %rax, 0x8(%rsp)
movabsq $0x100000001, %rbp      # imm = 0x100000001
movq %rbp, 0x8(%rax)
leaq 0x43bc(%rip), %rcx      # 0x9c88
movq %rcx, (%rax)
leaq 0x442a(%rip), %rcx      # 0x9d00
movq %rax, 0x50(%rsp)
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
cmpl $0x0, 0x4891(%rip)      # 0xa188
je 0x5960
xorl %r15d, %r15d
leaq 0x4435(%rip), %rbx      # 0x9d38
leaq 0x447e(%rip), %r14      # 0x9d88
leaq 0x30(%rsp), %r12
leaq 0x20(%rsp), %r13
movl $0x18, %edi
callq 0x21b0
movq %rbp, 0x8(%rax)
movq %rbx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
movq %r14, 0x10(%rax)
movq %rax, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x5a9a
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5954
callq 0x3cdc
incl %r15d
cmpl 0x482a(%rip), %r15d     # 0xa188
jb 0x5914
movq 0x50(%rsp), %r14
addq $0x10, %r14
movq %r14, 0x10(%rsp)
movq 0x8(%rsp), %rbx
movq %rbx, 0x18(%rsp)
movq 0x4651(%rip), %rax      # 0x9fd0
cmpb $0x0, (%rax)
je 0x5989
incl 0x8(%rbx)
jmp 0x598d
lock
incl 0x8(%rbx)
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3414
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x59ab
callq 0x3cdc
callq 0x21e0
movq %rax, %r12
movq 0x461e(%rip), %rdi      # 0x9fd8
leaq 0x923(%rip), %rsi       # 0x62e4
movl $0x15, %edx
callq 0x21d0
subq 0x48(%rsp), %r12
xorps %xmm0, %xmm0
cvtsi2ss %r12, %xmm0
divss 0x900(%rip), %xmm0      # 0x62e0
cvtss2sd %xmm0, %xmm0
movq 0x45ed(%rip), %rdi      # 0x9fd8
callq 0x2250
movq %rax, %r15
leaq 0x900(%rip), %rsi       # 0x62fa
movl $0x8, %edx
movq %rax, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x30(%rsp), %rdi
callq 0x5ae0
movq %rbx, %rdi
callq 0x3cdc
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
jmp 0x5a73
jmp 0x5a66
movq %rax, %r14
jmp 0x5a7d
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5a7d
callq 0x3cdc
leaq 0x30(%rsp), %rdi
callq 0x5ae0
movq 0x8(%rsp), %rdi
callq 0x3cdc
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/codeandkey[P]neocortex/src/attacks.cpp
// Function: make_rocc(int, unsigned long, int)
bitboard make_rocc(int index, bitboard mask, int bits) {
	bitboard output = 0;

	for (int i = 0; i < bits; ++i) {
		if ((index >> i) & 1) {
			/* The ith bit in mask should be passed to result. */

			int currentbit = -1;
			for (int maskpos = 0; maskpos < 64; ++maskpos) {
				if ((mask >> maskpos) & 1) {
					if (++currentbit == i) {
						/* Pass this bit on! */
						output |= (1ULL << maskpos);
					}
				}
			}
		}
	}

	return output;
}

// Assembly:
xorl %r8d, %r8d
testl %edx, %edx
jle 0x5856
pushq %rbx
xorl %r9d, %r9d
xorl %eax, %eax
btl %r9d, %edi
jae 0x584c
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl $0x1, %r11d
shlq %cl, %r11
leal 0x1(%r10), %ebx
cmpl %r9d, %ebx
cmovneq %r8, %r11
btq %rcx, %rsi
cmovaeq %r8, %r11
cmovael %r10d, %ebx
orq %r11, %rax
incq %rcx
movl %ebx, %r10d
cmpq $0x40, %rcx
jne 0x581d
incl %r9d
cmpl %edx, %r9d
jne 0x580f
popq %rbx
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/codeandkey[P]neocortex/src/bitboard.cpp
// Function: neocortex::bb::to_string[abi:cxx11](unsigned long)
std::string bb::to_string(bitboard inp) {
	std::string output;

	for (int r = 7; r >= 0; --r) {
		for (int f = 0; f < 8; ++f) {
			if (bb::mask(square::at(r, f)) & inp) {
				output += '1';
			} else {
				output += '.';
			}
		}

		output += '\n';
	}

	return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x7, %r12d
movl $0x38, %r13d
xorl %ebp, %ebp
movl %ebp, %eax
orl %r12d, %eax
testl $0xfffffff8, %eax       # imm = 0xFFFFFFF8
jne 0x5eef
leal (%r13,%rbp), %eax
xorl %ecx, %ecx
btq %rax, %r14
setb %cl
leal (%rcx,%rcx,2), %esi
addl $0x2e, %esi
movq %rbx, %rdi
callq 0x4240
incq %rbp
cmpq $0x8, %rbp
jne 0x5e95
movq %rbx, %rdi
movl $0xa, %esi
callq 0x4240
addq $-0x8, %r13
subq $0x1, %r12
jae 0x5e93
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12b8d(%rip), %rdi     # 0x18a83
leaq 0x12b79(%rip), %rsi     # 0x18a76
leaq 0x12bae(%rip), %rcx     # 0x18ab2
movl $0x22, %edx
callq 0x4190
jmp 0x5f10
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x5f26
movq (%r15), %rsi
incq %rsi
callq 0x42b0
movq %r14, %rdi
callq 0x44f0
nop