LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: UTSASRG[P]Guarder/./hashmap.hh
// Function: HashMap<void*, BigHeap::bigObjectStatus*, HeapAllocator>::getEntry(HashMap<void*, BigHeap::bigObjectStatus*, HeapAllocator>::HashEntry*, void* const&, unsigned long)
struct Entry* getEntry(struct HashEntry* first, const KeyType& key, size_t keylen) {
    struct Entry* entry = (struct Entry*)first->getFirstEntry();
    struct Entry* result = NULL;

    // Check all _entries with the same hindex.
    int count = first->count;
    // PRINF("getEntry count is %d\n", count);
    while(count > 0) {
      if(entry->keylen == keylen && _keycmp(entry->key, key, keylen)) {
        result = entry;
        break;
      }

      entry = entry->nextEntry();
      count--;
    }

    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5970
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0xb029
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0xb011
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x18(%rbp), %rcx
movq (%rcx), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
testb $0x1, %al
jne 0xb007
jmp 0xb011
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xb029
movq -0x28(%rbp), %rdi
callq 0x5350
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xafd0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xb0ca
jmp 0xb0e9
leaq 0x1baf(%rip), %rdi      # 0xcc80
leaq 0x1bbd(%rip), %rsi      # 0xcc95
movl $0xbd, %edx
leaq 0x25d9(%rip), %rcx      # 0xd6bd
callq 0x5300
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54e0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x5770
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x5710
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xb149
movb $0x1, -0x31(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5930
movq -0x30(%rbp), %rdi
callq 0x5330
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: UTSASRG[P]Guarder/./bigheap.hh
// Function: BigHeap::getUsableSize(void*)
size_t getUsableSize(void * ptr) {
    bigObjectStatus * objStatus;
    if(!_xmap.find(ptr, sizeof(void *), &objStatus)) {
      return 0;
    }
    return objStatus->usableSize;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
leaq -0x20(%rbp), %rcx
callq 0x52b0
testb $0x1, %al
jne 0xb2e8
movq $0x0, -0x8(%rbp)
jmp 0xb2f4
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x5370
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x5090
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rdi
callq *%rax
movq %rax, -0x30(%rbp)
jmp 0xb581
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xb5f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xb600
movq -0x20(%rbp), %rdi
callq 0x51b0
movl (%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x8b6, -0x28(%rbp)     # imm = 0x8B6
je 0xb5f1
movl $0x4, %edi
callq 0x5200
movq %rax, %rdi
movl -0x28(%rbp), %eax
movl %eax, (%rdi)
movq 0x5905(%rip), %rsi      # 0x10ed8
xorl %eax, %eax
movl %eax, %edx
callq 0x5870
jmp 0xb609
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5820
jmp 0xb600
callq 0x5820
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5890
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xb63d
jmp 0xb65c
leaq 0x163c(%rip), %rdi      # 0xcc80
leaq 0x164a(%rip), %rsi      # 0xcc95
movl $0xab, %edx
leaq 0x22e3(%rip), %rcx      # 0xd93a
callq 0x5300
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5740
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x56d0
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
movb $0x1, -0x39(%rbp)
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x5430
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xb6c3
movq -0x48(%rbp), %rdi
movb $0x0, -0x39(%rbp)
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
callq 0x5480
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/wordQueryTest.cc
// Function: main
int main(int argc, char **argv)
{
    TextQuery file = get_file(argc, argv);

    // iterate with the user: prompt for a word to find and print results
    do {
        string sought;
        if (!get_word(sought)) break;

        // find all the occurrences of the requested string
        // define synonym for the line_no set 
        Query name(sought);
        const auto results = name.eval(file);
        cout << "\nExecuting Query for: " << name << endl;

        // report no matches
        print(cout, results) << endl;
    } while (true);  // loop indefinitely; the exit is inside the loop
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0xb510
leaq -0x70(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x32e0
movq -0xe0(%rbp), %rdi
callq 0xb660
movb %al, -0xd1(%rbp)
jmp 0x72ad
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x72d6
jmp 0x72b9
movl $0x2, -0x80(%rbp)
jmp 0x739e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x7415
leaq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x7430
jmp 0x72e8
leaq -0xd0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x3e80
jmp 0x7301
movq 0xbcc0(%rip), %rdi      # 0x12fc8
leaq 0x4e19(%rip), %rsi      # 0xc128
callq 0x3220
movq %rax, -0xe8(%rbp)
jmp 0x731d
movq -0xe8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x74a0
movq %rax, -0xf0(%rbp)
jmp 0x7339
movq -0xf0(%rbp), %rdi
movq 0xbc61(%rip), %rsi      # 0x12fa8
callq 0x3260
jmp 0x734e
movq 0xbc73(%rip), %rdi      # 0x12fc8
leaq -0xd0(%rbp), %rsi
callq 0x83b0
movq %rax, -0xf8(%rbp)
jmp 0x736a
movq -0xf8(%rbp), %rdi
movq 0xbc30(%rip), %rsi      # 0x12fa8
callq 0x3260
jmp 0x737f
leaq -0xd0(%rbp), %rdi
callq 0x4210
leaq -0x90(%rbp), %rdi
callq 0x4cd0
movl $0x0, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3160
movl -0x80(%rbp), %eax
testl %eax, %eax
je 0x73b2
jmp 0x73b0
jmp 0x73c0
jmp 0x73b4
movb $0x1, %al
testb $0x1, %al
jne 0x7289
jmp 0x73c0
movl $0x0, -0x4(%rbp)
movl $0x1, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7510
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x7409
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x4210
leaq -0x90(%rbp), %rdi
callq 0x4cd0
leaq -0x70(%rbp), %rdi
callq 0x3160
leaq -0x50(%rbp), %rdi
callq 0x7510
movq -0x78(%rbp), %rdi
callq 0x3370
// File: 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
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x32e0
movq -0x10(%rbp), %rdi
callq 0x3210
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8ac0
testb $0x1, %al
jne 0x8011
jmp 0x806c
leaq -0x20(%rbp), %rdi
callq 0x8b00
movsbl (%rax), %edi
callq 0x33c0
cmpl $0x0, %eax
jne 0x805f
leaq -0x20(%rbp), %rdi
callq 0x8b00
movsbl (%rax), %edi
callq 0x3300
movq -0x48(%rbp), %rdi
movsbl %al, %esi
callq 0x3170
jmp 0x8046
jmp 0x805f
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x3160
jmp 0x8089
jmp 0x8061
leaq -0x20(%rbp), %rdi
callq 0x8b20
jmp 0x7ff1
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x807f
movq -0x48(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3370
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x10, %rdi
callq 0x8d60
movq -0x50(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x10, %rdi
callq 0x8d90
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x8dc0
testb $0x1, %al
jne 0x86f8
jmp 0x881a
movq 0xa8c9(%rip), %rdi      # 0x12fc8
leaq 0x3a9d(%rip), %rsi      # 0xc1a3
callq 0x3220
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x8c00
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x3200
movq %rax, %rdi
leaq 0x3a7c(%rip), %rsi      # 0xc1aa
callq 0x3220
leaq -0x10(%rbp), %rdi
callq 0x8c00
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x28(%rbp), %rdi
callq 0x4160
leaq -0x28(%rbp), %rdi
callq 0x4090
movq %rax, %rdi
callq 0x48b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4090
movq %rax, %rdi
callq 0x4930
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4100
testb $0x1, %al
jne 0x8789
jmp 0x87ee
leaq -0x30(%rbp), %rdi
callq 0x4060
movq (%rax), %rsi
movq 0xa82c(%rip), %rdi      # 0x12fc8
callq 0x3070
jmp 0x87a3
leaq -0x30(%rbp), %rdi
callq 0x4130
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x4100
testb $0x1, %al
jne 0x87be
jmp 0x87ec
movq 0xa803(%rip), %rdi      # 0x12fc8
leaq 0x39e1(%rip), %rsi      # 0xc1ad
callq 0x3220
jmp 0x87d3
jmp 0x87ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x41f0
jmp 0x8833
jmp 0x8776
movq 0xa7d3(%rip), %rdi      # 0x12fc8
leaq 0x39b4(%rip), %rsi      # 0xc1b0
callq 0x3220
jmp 0x8803
leaq -0x28(%rbp), %rdi
callq 0x41f0
leaq -0x10(%rbp), %rdi
callq 0x8df0
jmp 0x86e2
movq 0xa7a7(%rip), %rdi      # 0x12fc8
movq 0xa780(%rip), %rsi      # 0x12fa8
callq 0x3260
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3370
nopl (%rax)
// File: 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
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x240(%rbp)
movq %rdi, %rax
movq %rax, -0x238(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x3280
cmpl $0x2, -0xc(%rbp)
jne 0xb57d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x3180
jmp 0xb564
jmp 0xb57d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0xb63b
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x3100
movb %al, -0x241(%rbp)
jmp 0xb59d
movb -0x241(%rbp), %al
testb $0x1, %al
jne 0xb5a9
jmp 0xb60a
movl $0x10, %edi
callq 0x3120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x250(%rbp)
leaq 0xccd(%rip), %rsi       # 0xc294
callq 0x30d0
jmp 0xb5ce
movq -0x250(%rbp), %rdi
movq 0x7a14(%rip), %rsi      # 0x12ff0
movq 0x79d5(%rip), %rdx      # 0x12fb8
callq 0x3360
jmp 0xb653
movq -0x250(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
callq 0x31d0
jmp 0xb63b
movq -0x240(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x7cc0
jmp 0xb61f
leaq -0x220(%rbp), %rdi
callq 0x3090
movq -0x238(%rbp), %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x3090
movq -0x228(%rbp), %rdi
callq 0x3370
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq 0x7955(%rip), %rdi      # 0x12fc8
leaq 0xc29(%rip), %rsi       # 0xc2a3
callq 0x3220
movq -0x10(%rbp), %rsi
movq 0x794e(%rip), %rdi      # 0x12fd8
callq 0x32c0
movq 0x7942(%rip), %rax      # 0x12fd8
movq (%rax), %rax
movq 0x7938(%rip), %rdi      # 0x12fd8
addq -0x18(%rax), %rdi
callq 0x3100
testb $0x1, %al
jne 0xb6c3
movq -0x10(%rbp), %rdi
leaq 0xc16(%rip), %rsi       # 0xc2ce
callq 0xb770
testb $0x1, %al
jne 0xb6c3
jmp 0xb6c9
movb $0x0, -0x1(%rbp)
jmp 0xb6cd
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x78d1(%rip), %rdi      # 0x12fc8
leaq 0xbd2(%rip), %rsi       # 0xc2d0
callq 0x3220
movq -0x10(%rbp), %rsi
movq 0x78ca(%rip), %rdi      # 0x12fd8
callq 0x32c0
movq 0x78be(%rip), %rax      # 0x12fd8
movq (%rax), %rax
movq 0x78b4(%rip), %rdi      # 0x12fd8
addq -0x18(%rax), %rdi
callq 0x3100
testb $0x1, %al
jne 0xb747
movq -0x10(%rbp), %rdi
leaq 0xb92(%rip), %rsi       # 0xc2ce
callq 0xb770
testb $0x1, %al
jne 0xb747
jmp 0xb74d
movb $0x0, -0x1(%rbp)
jmp 0xb761
movq -0x18(%rbp), %rsi
movq 0x7880(%rip), %rdi      # 0x12fd8
callq 0x32c0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x2c(%rbp), %rdi
xorps %xmm0, %xmm0
movss 0x109f6(%rip), %xmm1    # 0x14004
callq 0x4730
leaq -0x2c(%rbp), %rdi
leaq 0x1f02a(%rip), %rsi     # 0x22648
callq 0x4760
movaps %xmm0, %xmm1
movss -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x3657
movq -0x88(%rbp), %rdi
callq 0x4790
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x8(%rbp)
jmp 0x36d2
movq -0x20(%rbp), %rdi
callq 0x47b0
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
callq 0x47e0
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x4810
movq -0x98(%rbp), %rdi
leaq 0x1efb1(%rip), %rsi     # 0x22648
callq 0x4850
movq %rax, -0x90(%rbp)
jmp 0x36a5
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4880
jmp 0x36d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4880
jmp 0x36df
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3350
nopl (%rax,%rax)
// File: integeruser[P]GA3C-cpp/src/ga3c.cc
// Function: fit(std::vector<std::tuple<std::vector<float, std::allocator<float>>, long, float>, std::allocator<std::tuple<std::vector<float, std::allocator<float>>, long, float>>> const&)
void fit(const std::vector<training_experience_t>& batch)
{
    std::vector<observation_t> states;
    std::vector<action_t> actions;
    std::vector<float> rewards;

    observation_t state;
    action_t action;
    float reward;
    for (const auto& experience: batch) {
        std::tie(state, action, reward) = experience;
        states.push_back(state);
        actions.push_back(action);
        rewards.push_back(reward);
    }
    shared_model->fit(states, actions, rewards);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x52d0
leaq -0x38(%rbp), %rdi
callq 0x52f0
leaq -0x50(%rbp), %rdi
callq 0x4c20
leaq -0x68(%rbp), %rdi
callq 0x4c20
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x5310
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
callq 0x5340
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x5370
testb $0x1, %al
jne 0x4007
jmp 0x40d4
leaq -0x88(%rbp), %rdi
callq 0x53b0
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x68(%rbp), %rsi
leaq -0x70(%rbp), %rdx
leaq -0x74(%rbp), %rcx
callq 0x53d0
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x5410
jmp 0x405c
leaq -0x20(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5440
jmp 0x406b
leaq -0x38(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x54b0
jmp 0x407a
leaq -0x50(%rbp), %rdi
leaq -0x74(%rbp), %rsi
callq 0x5520
jmp 0x4089
jmp 0x408b
leaq -0x88(%rbp), %rdi
callq 0x5590
jmp 0x3feb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4bc0
leaq -0x50(%rbp), %rdi
callq 0x4bc0
leaq -0x38(%rbp), %rdi
callq 0x55b0
leaq -0x20(%rbp), %rdi
callq 0x5610
jmp 0x4126
leaq 0x1d125(%rip), %rdi     # 0x21200
callq 0x4c90
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
leaq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq *%rax
jmp 0x40f9
leaq -0x68(%rbp), %rdi
callq 0x4bc0
leaq -0x50(%rbp), %rdi
callq 0x4bc0
leaq -0x38(%rbp), %rdi
callq 0x55b0
leaq -0x20(%rbp), %rdi
callq 0x5610
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x3350
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movl 0x1d167(%rip), %eax     # 0x212b8
leaq 0x1d094(%rip), %rcx     # 0x211ec
cmpl (%rcx), %eax
jae 0x4272
leaq 0x1d085(%rip), %rax     # 0x211ec
movl (%rax), %eax
movl 0x1d149(%rip), %ecx     # 0x212b8
subl %ecx, %eax
movl %eax, -0x8(%rbp)
leaq 0x100f5(%rip), %rdi     # 0x14270
leaq -0x8(%rbp), %rsi
callq 0x48d0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x70(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5670
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x5690
jmp 0x41b0
leaq -0x21(%rbp), %rdi
callq 0x5700
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5720
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x424a
leaq 0x1d02d(%rip), %rsi     # 0x21210
leaq -0x60(%rbp), %rdi
callq 0x5750
jmp 0x41ee
movl -0x38(%rbp), %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x5810
movq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x5830
leaq -0x60(%rbp), %rdi
callq 0x4f90
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x41c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x5700
jmp 0x427b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5870
jmp 0x427b
leaq -0x20(%rbp), %rdi
callq 0x3f90
jmp 0x4255
movl -0x4(%rbp), %eax
addl 0x1d05a(%rip), %eax     # 0x212b8
movl %eax, 0x1d054(%rip)     # 0x212b8
leaq -0x20(%rbp), %rdi
callq 0x5870
jmp 0x414b
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3350
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xc550
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
callq 0xf6f0
jmp 0x579e
movq -0x48(%rbp), %rdi
movb $0x0, -0x35(%rbp)
addq $0x58, %rdi
callq 0xf740
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xf780
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
callq 0xf7b0
movb $0x1, -0x35(%rbp)
testb $0x1, -0x35(%rbp)
jne 0x57f4
jmp 0x57eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc5f0
jmp 0x5807
movq -0x58(%rbp), %rdi
callq 0x4f90
leaq -0x20(%rbp), %rdi
callq 0xc5f0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3350
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3270
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x111d0
leaq -0x40(%rbp), %rdi
callq 0x11240
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl 0x101d4(%rip), %eax     # 0x211e8
jae 0x1106f
leaq -0x58(%rbp), %rdi
callq 0x11260
jmp 0x11021
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x112d0
jmp 0x11030
leaq -0x58(%rbp), %rdi
callq 0x4db0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1100b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x111aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4db0
jmp 0x111aa
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x11340
movq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4290
jmp 0x11095
leaq -0x78(%rbp), %rdi
callq 0x4560
callq 0x3270
movq %rax, -0x80(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11370
movq %rax, -0xa0(%rbp)
jmp 0x110bd
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x84(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x113c0
jmp 0x110e0
movq 0xfef1(%rip), %rdi      # 0x20fd8
leaq 0x3222(%rip), %rsi      # 0x14310
callq 0x31d0
movq %rax, -0xa8(%rbp)
jmp 0x110fc
leaq -0x84(%rbp), %rdi
callq 0x11400
movss %xmm0, -0xac(%rbp)
jmp 0x11112
movss -0xac(%rbp), %xmm0
movq -0xa8(%rbp), %rdi
callq 0x3140
movq %rax, -0xb8(%rbp)
jmp 0x1112f
movq -0xb8(%rbp), %rdi
leaq 0x31e9(%rip), %rsi      # 0x14326
callq 0x31d0
movq %rax, -0xc0(%rbp)
jmp 0x1114b
movq -0xc0(%rbp), %rdi
movq 0xfe5f(%rip), %rsi      # 0x20fb8
callq 0x3200
jmp 0x11160
leaq -0x28(%rbp), %rdi
callq 0x4c90
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x11177
leaq -0x40(%rbp), %rdi
callq 0x11420
leaq -0x28(%rbp), %rdi
callq 0x4560
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4560
leaq -0x40(%rbp), %rdi
callq 0x11420
leaq -0x28(%rbp), %rdi
callq 0x4560
movq -0x60(%rbp), %rdi
callq 0x3350
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6b21
movl -0x4(%rbp), %eax
movl -0x24(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6b11
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x2c(%rbp)
cmpl $0x40, -0x2c(%rbp)
jge 0x6b0f
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
shrq %cl, %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x6b02
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl -0x24(%rbp), %eax
jne 0x6b00
movl -0x2c(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x6b02
jmp 0x6b04
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6ac3
jmp 0x6b11
jmp 0x6b13
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6a9d
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5540
movl $0x7, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x73b6
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x7396
movl -0x18(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x6c20
movl %eax, -0x44(%rbp)
jmp 0x7332
movl -0x44(%rbp), %edi
callq 0x6bd0
movq %rax, -0x50(%rbp)
jmp 0x7340
movq -0x50(%rbp), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x7377
movq -0x40(%rbp), %rdi
movl $0x31, %esi
callq 0x5250
jmp 0x735e
jmp 0x7389
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5230
jmp 0x73d3
movq -0x40(%rbp), %rdi
movl $0x2e, %esi
callq 0x5250
jmp 0x7387
jmp 0x7389
jmp 0x738b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x731c
movq -0x40(%rbp), %rdi
movl $0xa, %esi
callq 0x5250
jmp 0x73a6
jmp 0x73a8
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x730b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x73c9
movq -0x40(%rbp), %rdi
callq 0x5230
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
nopl (%rax)
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::Board()
Board::Board() {
	for (int i = 0; i < 64; ++i) {
		state[i] = -1;
	}

	for (int c = 0; c < 2; ++c) {
		color_occ[c] = 0;
	}

	for (int p = 0; p < 6; ++p) {
		piece_occ[p] = 0;
	}

	key = 0;
	global_occ = 0;
	mat_mg = mat_eg = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x7488
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x48(%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7467
movl $0x0, -0x10(%rbp)
cmpl $0x2, -0x10(%rbp)
jge 0x74b1
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, 0x8(%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x748f
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x74da
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, 0x18(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x74b8
movq -0x20(%rbp), %rax
movq $0x0, 0x150(%rax)
movq $0x0, (%rax)
movl $0x0, 0x14c(%rax)
movl $0x0, 0x148(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::place(int, int)
void Board::place(int sq, int p) {
	assert(square::is_valid(sq));
	assert(piece::is_valid(p));
	assert(state[sq] == piece::null);

	state[sq] = p;

	bitboard mask = bb::mask(sq);

	global_occ ^= mask;
	piece_occ[piece::type(p)] ^= mask;
	color_occ[piece::color(p)] ^= mask;
	key ^= zobrist::piece(sq, p);
	mat_mg += eval::MATERIAL_MG_LOOKUP[p];
	mat_eg += eval::MATERIAL_EG_LOOKUP[p];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x6d10
testb $0x1, %al
jne 0x7ba8
jmp 0x7baa
jmp 0x7bc9
leaq 0x1df14(%rip), %rdi     # 0x25ac5
leaq 0x1e06e(%rip), %rsi     # 0x25c26
movl $0x4f, %edx
leaq 0x1e070(%rip), %rcx     # 0x25c34
callq 0x5290
movl -0x10(%rbp), %edi
callq 0x8cf0
testb $0x1, %al
jne 0x7bd7
jmp 0x7bd9
jmp 0x7bf8
leaq 0x1e07b(%rip), %rdi     # 0x25c5b
leaq 0x1e03f(%rip), %rsi     # 0x25c26
movl $0x50, %edx
leaq 0x1e041(%rip), %rcx     # 0x25c34
callq 0x5290
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, 0x48(%rax,%rcx,4)
jne 0x7c09
jmp 0x7c28
leaq 0x1e05e(%rip), %rdi     # 0x25c6e
leaq 0x1e00f(%rip), %rsi     # 0x25c26
movl $0x51, %edx
leaq 0x1e011(%rip), %rcx     # 0x25c34
callq 0x5290
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %edx
movslq -0xc(%rbp), %rcx
movl %edx, 0x48(%rax,%rcx,4)
movl -0xc(%rbp), %edi
callq 0x6bd0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %edi
callq 0x8d20
movq -0x30(%rbp), %rdx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
xorq 0x18(%rax,%rcx,8), %rdx
movq %rdx, 0x18(%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %edi
callq 0x8d70
movq -0x28(%rbp), %rdx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
xorq 0x8(%rax,%rcx,8), %rdx
movq %rdx, 0x8(%rax,%rcx,8)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x23cc0
movq %rax, %rcx
movq -0x20(%rbp), %rax
xorq 0x150(%rax), %rcx
movq %rcx, 0x150(%rax)
movslq -0x10(%rbp), %rdx
leaq 0x1ec03(%rip), %rcx     # 0x268d0
movl (%rcx,%rdx,4), %ecx
addl 0x148(%rax), %ecx
movl %ecx, 0x148(%rax)
movslq -0x10(%rbp), %rdx
leaq 0x1ec19(%rip), %rcx     # 0x26900
movl (%rcx,%rdx,4), %ecx
addl 0x14c(%rax), %ecx
movl %ecx, 0x14c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::remove(int)
int Board::remove(int sq) {
	assert(square::is_valid(sq));
	assert(piece::is_valid(state[sq]));

	int res = state[sq];

	bitboard mask = bb::mask(sq);

	global_occ ^= mask;
	piece_occ[piece::type(res)] ^= mask;
	color_occ[piece::color(res)] ^= mask;
	key ^= zobrist::piece(sq, res);

	state[sq] = piece::null;

	mat_mg -= eval::MATERIAL_MG_LOOKUP[res];
	mat_eg -= eval::MATERIAL_EG_LOOKUP[res];

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x6d10
testb $0x1, %al
jne 0x7dc5
jmp 0x7dc7
jmp 0x7de6
leaq 0x1dcf7(%rip), %rdi     # 0x25ac5
leaq 0x1de51(%rip), %rsi     # 0x25c26
movl $0x60, %edx
leaq 0x1dea6(%rip), %rcx     # 0x25c87
callq 0x5290
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x48(%rax,%rcx,4), %edi
callq 0x8cf0
testb $0x1, %al
jne 0x7dfd
jmp 0x7dff
jmp 0x7e1e
leaq 0x1dea3(%rip), %rdi     # 0x25ca9
leaq 0x1de19(%rip), %rsi     # 0x25c26
movl $0x61, %edx
leaq 0x1de6e(%rip), %rcx     # 0x25c87
callq 0x5290
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x48(%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0x6bd0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %edi
callq 0x8d20
movq -0x30(%rbp), %rdx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
xorq 0x18(%rax,%rcx,8), %rdx
movq %rdx, 0x18(%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %edi
callq 0x8d70
movq -0x28(%rbp), %rdx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
xorq 0x8(%rax,%rcx,8), %rdx
movq %rdx, 0x8(%rax,%rcx,8)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x23cc0
movq %rax, %rcx
movq -0x20(%rbp), %rax
xorq 0x150(%rax), %rcx
movq %rcx, 0x150(%rax)
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x48(%rax,%rcx,4) # imm = 0xFFFFFFFF
movslq -0x10(%rbp), %rdx
leaq 0x1ea01(%rip), %rcx     # 0x268d0
movl (%rcx,%rdx,4), %edx
movl 0x148(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x148(%rax)
movslq -0x10(%rbp), %rdx
leaq 0x1ea15(%rip), %rcx     # 0x26900
movl (%rcx,%rdx,4), %edx
movl 0x14c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x14c(%rax)
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::to_uci[abi:cxx11]()
std::string Board::to_uci() {
	std::string output;

	int null_count = 0;

	for (int r = 7; r >= 0; --r) {
		for (int f = 0; f < 8; ++f) {
			int sq = square::at(r, f);

			if (state[sq] == piece::null) {
				null_count++;
			} else {
				if (null_count > 0) {
					output += '0' + null_count;
					null_count = 0;
				}

				output += piece::get_uci(state[sq]);
			}
		}

		if (null_count > 0) {
			output += '0' + null_count;
			null_count = 0;
		}

		if (r) output += '/';
	}

	return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5540
movl $0x0, -0x18(%rbp)
movl $0x7, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x8252
movl $0x0, -0x20(%rbp)
cmpl $0x8, -0x20(%rbp)
jge 0x8209
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x6c20
movl %eax, -0x54(%rbp)
jmp 0x8175
movq -0x40(%rbp), %rax
movl -0x54(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movslq -0x24(%rbp), %rcx
cmpl $-0x1, 0x48(%rax,%rcx,4)
jne 0x81af
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x81f9
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x5230
jmp 0x826f
cmpl $0x0, -0x18(%rbp)
jle 0x81d0
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $0x30, %eax
movsbl %al, %esi
callq 0x5250
jmp 0x81c9
movl $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x48(%rax,%rcx,4), %edi
callq 0xbdf0
movb %al, -0x55(%rbp)
jmp 0x81e6
movq -0x50(%rbp), %rdi
movb -0x55(%rbp), %al
movsbl %al, %esi
callq 0x5250
jmp 0x81f7
jmp 0x81f9
jmp 0x81fb
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x815b
cmpl $0x0, -0x18(%rbp)
jle 0x822a
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $0x30, %eax
movsbl %al, %esi
callq 0x5250
jmp 0x8223
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8242
movq -0x50(%rbp), %rdi
movl $0x2f, %esi
callq 0x5250
jmp 0x8240
jmp 0x8242
jmp 0x8244
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x814a
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8265
movq -0x50(%rbp), %rdi
callq 0x5230
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x56c0
nopl (%rax,%rax)
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::to_pretty[abi:cxx11]()
std::string Board::to_pretty() {
	std::string output;

	for (int r = 7; r >= 0; --r) {
		for (int f = 0; f < 8; ++f) {
			int sq = square::at(r, f);

			if (state[sq] == piece::null) {
				output += '.';
			} else {
				output += piece::get_uci(state[sq]);
			}
		}

		output += '\n';
	}

	return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5540
movl $0x7, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x8375
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x8355
movl -0x18(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x6c20
movl %eax, -0x4c(%rbp)
jmp 0x82de
movq -0x38(%rbp), %rax
movl -0x4c(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movslq -0x20(%rbp), %rcx
cmpl $-0x1, 0x48(%rax,%rcx,4)
jne 0x831c
movq -0x48(%rbp), %rdi
movl $0x2e, %esi
callq 0x5250
jmp 0x8303
jmp 0x8345
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5230
jmp 0x8392
movq -0x38(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl 0x48(%rax,%rcx,4), %edi
callq 0xbdf0
movb %al, -0x4d(%rbp)
jmp 0x8332
movq -0x48(%rbp), %rdi
movb -0x4d(%rbp), %al
movsbl %al, %esi
callq 0x5250
jmp 0x8343
jmp 0x8345
jmp 0x8347
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x82c4
movq -0x48(%rbp), %rdi
movl $0xa, %esi
callq 0x5250
jmp 0x8365
jmp 0x8367
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x82b3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8388
movq -0x48(%rbp), %rdi
callq 0x5230
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
nopl (%rax,%rax)
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::attacks_on(int)
bitboard Board::attacks_on(int sq) {
	assert(square::is_valid(sq));

	bitboard white_pawns = piece_occ[piece::PAWN] & color_occ[piece::WHITE];
	bitboard black_pawns = piece_occ[piece::PAWN] & color_occ[piece::BLACK];
	bitboard rooks_queens = piece_occ[piece::ROOK] | piece_occ[piece::QUEEN];
	bitboard bishops_queens = piece_occ[piece::BISHOP] | piece_occ[piece::QUEEN];

	return (attacks::pawn(piece::WHITE, sq) & black_pawns) |
		(attacks::pawn(piece::BLACK, sq) & white_pawns) |
		(attacks::knight(sq) & piece_occ[piece::KNIGHT]) |
		(attacks::bishop(sq, global_occ) & bishops_queens) |
		(attacks::rook(sq, global_occ) & rooks_queens) |
		(attacks::king(sq) & piece_occ[piece::KING]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %edi
callq 0x6d10
testb $0x1, %al
jne 0x83c5
jmp 0x83c7
jmp 0x83e6
leaq 0x1d6f7(%rip), %rdi     # 0x25ac5
leaq 0x1d851(%rip), %rsi     # 0x25c26
movl $0xc3, %edx
leaq 0x1d90b(%rip), %rcx     # 0x25cec
callq 0x5290
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rax
andq 0x8(%rcx), %rax
movq %rax, -0x18(%rbp)
movq 0x18(%rcx), %rax
andq 0x10(%rcx), %rax
movq %rax, -0x20(%rbp)
movq 0x30(%rcx), %rax
orq 0x38(%rcx), %rax
movq %rax, -0x28(%rbp)
movq 0x20(%rcx), %rax
orq 0x38(%rcx), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %esi
xorl %edi, %edi
callq 0x8dc0
andq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %esi
movl $0x1, %edi
callq 0x8dc0
movq %rax, %rcx
movq -0x60(%rbp), %rax
andq -0x18(%rbp), %rcx
orq %rcx, %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %edi
callq 0x8df0
movq -0x58(%rbp), %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
andq 0x28(%rax), %rdx
orq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movl -0xc(%rbp), %edi
movq (%rax), %rsi
callq 0x8e10
movq -0x50(%rbp), %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
andq -0x30(%rbp), %rdx
orq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movl -0xc(%rbp), %edi
movq (%rax), %rsi
callq 0x8eb0
movq %rax, %rcx
movq -0x48(%rbp), %rax
andq -0x28(%rbp), %rcx
orq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %edi
callq 0x8f50
movq -0x38(%rbp), %rdx
movq %rax, %rcx
movq -0x40(%rbp), %rax
andq 0x40(%rdx), %rcx
orq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::guard_value(int)
int Board::guard_value(int sq) {
	int val = 0;
	bitboard att = attacks_on(sq);

	while (att) {
		val += eval::GUARD_VALUES[state[bb::poplsb(att)]];
	}

	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %esi
callq 0x83a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x852a
leaq -0x18(%rbp), %rdi
callq 0x8f70
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
movslq 0x48(%rax,%rcx,4), %rcx
leaq 0x1e431(%rip), %rax     # 0x26950
movl (%rax,%rcx,4), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x84fa
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::mask_is_attacked(unsigned long, int)
bool Board::mask_is_attacked(bitboard mask, int col) {
	bitboard opp = color_occ[col];

	while (mask) {
		if (attacks_on(bb::poplsb(mask)) & opp) return true;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x1c(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8595
leaq -0x18(%rbp), %rdi
callq 0x8f70
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x83a0
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0x8593
movb $0x1, -0x1(%rbp)
jmp 0x8599
jmp 0x8568
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::all_spans(int)
bitboard Board::all_spans(int col) {
	bitboard out = 0;
	bitboard pawns = piece_occ[piece::PAWN] & color_occ[col];

	while (pawns) {
		int p = bb::poplsb(pawns);

		out |= attacks::pawn_attackspans(col, p);
		out |= attacks::pawn_frontspans(col, p);
	}

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq $0x0, -0x18(%rbp)
movq 0x18(%rcx), %rax
movslq -0xc(%rbp), %rdx
andq 0x8(%rcx,%rdx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8617
leaq -0x20(%rbp), %rdi
callq 0x8f70
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x8fb0
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x8fe0
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x85dc
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: codeandkey[P]neocortex/src/board.cpp
// Function: neocortex::Board::front_spans(int)
bitboard Board::front_spans(int col) {
	bitboard out = 0;
	bitboard pawns = piece_occ[piece::PAWN] & color_occ[col];

	while (pawns) {
		int p = bb::poplsb(pawns);

		out |= attacks::pawn_frontspans(col, p);
	}

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq $0x0, -0x18(%rbp)
movq 0x18(%rcx), %rax
movslq -0xc(%rbp), %rdx
andq 0x8(%rcx,%rdx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8684
leaq -0x20(%rbp), %rdi
callq 0x8f70
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x8fe0
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x865c
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop