LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: martinda3[P]Compiler/src/ASblockState.cpp
// Function: toyc::ASblockState::ASblockState(toyc::ASdefinition**, int, toyc::ASstatement**, int)
ASblockState::ASblockState(ASdefinition* varDef[], int numv, ASstatement* statements[], int nums)
	{
		for (int i = 0; i < numv; i++)
		{
			varDefList[i] = varDef[i];
		}
		numVarDef = numv;
		for (int i = 0; i < nums; i++)
		{
			statementList[i] = statements[i];
		}
		numStatements = nums;
		setType(BLOCKstate);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1ed40
movq -0x38(%rbp), %rax
leaq 0x170f5(%rip), %rcx     # 0x44c98
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2dbdd
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movslq -0x28(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2dbb1
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xfb0(%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x2dc20
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movslq -0x2c(%rbp), %rcx
movq %rdx, 0xfb8(%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2dbf1
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, 0x1f58(%rdi)
movl $0x2, %esi
callq 0x1ed80
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: martinda3[P]Compiler/src/ASprog.cpp
// Function: toyc::ASprog::ASprog(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, toyc::ASdefinition**, int)
ASprog::ASprog(std::string n, ASdefinition* definitions[], int num)
	{
		for (int i = 0; i < num; i++)
		{
			definitionList[i] = definitions[i];
		}
		numDefinitions = num;
		name = n;
		setType(PROGprog);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2e970
movq -0x40(%rbp), %rdi
leaq 0x169e5(%rip), %rax     # 0x44cc8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0xfb8, %rdi            # imm = 0xFB8
movq %rdi, -0x38(%rbp)
callq 0x9480
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2e32d
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movslq -0x20(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2e301
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, 0xfb0(%rdi)
addq $0xfb8, %rdi            # imm = 0xFB8
callq 0x9050
jmp 0x2e34c
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x1ea60
jmp 0x2e359
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9658
movq -0x28(%rbp), %rdi
callq 0x95b0
nopl (%rax)
// File: martinda3[P]Compiler/src/tc.cpp
// Function: main
int main(int argc, char *argv[]) {
    char buffer[80];
    string ffile(buffer);
    try { processCommandLine(argc, argv, ffile); }
    catch (...) {
        cerr << "ERROR: processCommandLine" << endl;
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x95c0
movq -0xc0(%rbp), %rdx
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x13550
jmp 0x2eb9b
leaq -0x81(%rbp), %rdi
callq 0x93b0
movl -0x4(%rbp), %eax
movl %eax, -0xcc(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x9170
jmp 0x2ebcd
movq -0xc8(%rbp), %rsi
movl -0xcc(%rbp), %edi
leaq -0xb8(%rbp), %rdx
callq 0x2ecf0
jmp 0x2ebe8
leaq -0xb8(%rbp), %rdi
callq 0x9658
jmp 0x2ecb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x81(%rbp), %rdi
callq 0x93b0
jmp 0x2eccd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x2ec4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x9658
movq -0x90(%rbp), %rdi
callq 0x9140
movq 0x1638f(%rip), %rdi     # 0x44ff0
leaq 0x6101(%rip), %rsi      # 0x34d69
callq 0x9340
movq %rax, -0xd8(%rbp)
jmp 0x2ec76
movq -0xd8(%rbp), %rdi
movq 0x1632c(%rip), %rsi     # 0x44fb0
callq 0x9380
jmp 0x2ec8b
movl $0x1, %edi
callq 0x9410
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
callq 0x9540
jmp 0x2ecae
leaq -0x80(%rbp), %rdi
callq 0x9658
jmp 0x2eccd
leaq -0x80(%rbp), %rdi
callq 0x9658
xorl %eax, %eax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x95b0
movq %rax, %rdi
callq 0x13a00
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/tc.cpp
// Function: printUsageMessage()
void printUsageMessage() {
    cout << "\nUsage: tc [Function] <input_file> " << endl;
    cout << "            -Function      -s        display all Scanner information" << endl;
    cout << "            -Function      -p        display all Parser information" << endl;
    cout << "            -Function      -a        display all abstract information" << endl;
    cout << "            -Function      -c        display all Completed information" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x14c4d(%rip), %rdi     # 0x44fc8
leaq 0x4aa4(%rip), %rsi      # 0x34e26
callq 0x9340
movq %rax, %rdi
movq 0x14c1f(%rip), %rsi     # 0x44fb0
callq 0x9380
movq 0x14c2b(%rip), %rdi     # 0x44fc8
leaq 0x4aa6(%rip), %rsi      # 0x34e4a
callq 0x9340
movq %rax, %rdi
movq 0x14bfd(%rip), %rsi     # 0x44fb0
callq 0x9380
movq 0x14c09(%rip), %rdi     # 0x44fc8
leaq 0x4ac9(%rip), %rsi      # 0x34e8f
callq 0x9340
movq %rax, %rdi
movq 0x14bdb(%rip), %rsi     # 0x44fb0
callq 0x9380
movq 0x14be7(%rip), %rdi     # 0x44fc8
leaq 0x4aeb(%rip), %rsi      # 0x34ed3
callq 0x9340
movq %rax, %rdi
movq 0x14bb9(%rip), %rsi     # 0x44fb0
callq 0x9380
movq 0x14bc5(%rip), %rdi     # 0x44fc8
leaq 0x4b0f(%rip), %rsi      # 0x34f19
callq 0x9340
movq %rax, %rdi
movq 0x14b97(%rip), %rsi     # 0x44fb0
callq 0x9380
popq %rbp
retq
// File: martinda3[P]Compiler/src/tc.cpp
// Function: inputFileHandler(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int inputFileHandler(string nameoffile) {
    string line;
    int count = 0;
    inputfile.open(nameoffile);
    if (inputfile.fail()) {
        std::cerr << "ERROR: input file not found" << std::endl;
        exit(EXIT_FAILURE);
    }
    while (!inputfile.eof()) {
        getline(inputfile, line);
        count++;
    }
    inputfile.close();
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9480
movq -0x48(%rbp), %rsi
movl $0x0, -0x2c(%rbp)
leaq 0x156e5(%rip), %rdi     # 0x45b30
movl $0x8, %edx
callq 0x92c0
jmp 0x30457
leaq 0x156d2(%rip), %rdi     # 0x45b30
movq 0x156cb(%rip), %rax     # 0x45b30
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x9030
movb %al, -0x49(%rbp)
jmp 0x30476
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x3047f
jmp 0x304cb
movq 0x14b6a(%rip), %rdi     # 0x44ff0
leaq 0x324f(%rip), %rsi      # 0x336dc
callq 0x9340
movq %rax, -0x58(%rbp)
jmp 0x30498
movq -0x58(%rbp), %rdi
movq 0x14b0d(%rip), %rsi     # 0x44fb0
callq 0x9380
jmp 0x304aa
movl $0x1, %edi
callq 0x9410
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9658
jmp 0x3053a
jmp 0x304cd
leaq 0x1565c(%rip), %rdi     # 0x45b30
movq 0x15655(%rip), %rax     # 0x45b30
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x95e0
movb %al, -0x59(%rbp)
jmp 0x304ec
movb -0x59(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x304f7
jmp 0x30514
leaq 0x15632(%rip), %rdi     # 0x45b30
leaq -0x28(%rbp), %rsi
callq 0x90c0
jmp 0x30509
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x304cd
leaq 0x15615(%rip), %rdi     # 0x45b30
callq 0x90d0
jmp 0x30522
movl -0x2c(%rbp), %eax
movl %eax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9658
movl -0x60(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/tc.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector <string> split(const string &s, char delim) {
    vector <string> result;
    stringstream ss(s);
    string item;
    while (getline(ss, item, delim)) {
        result.push_back(item);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f0(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x307a0
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x307c0
movl %eax, -0x1d4(%rbp)
jmp 0x305a4
movl -0x1d4(%rbp), %edx
movq -0x1e0(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x9510
jmp 0x305bf
leaq -0x1d0(%rbp), %rdi
callq 0x9480
movsbl -0x11(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x95f0
movq %rax, -0x1f8(%rbp)
jmp 0x305eb
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x9440
movb %al, -0x1f9(%rbp)
jmp 0x30609
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0x30615
jmp 0x3066c
movq -0x1f0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x307e0
jmp 0x3062a
jmp 0x305cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x306aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x9658
leaq -0x1a0(%rbp), %rdi
callq 0x9280
jmp 0x306aa
movb $0x1, -0x12(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x9658
leaq -0x1a0(%rbp), %rdi
callq 0x9280
testb $0x1, -0x12(%rbp)
jne 0x3069a
movq -0x1f0(%rbp), %rdi
callq 0x30850
movq -0x1e8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1f0(%rbp), %rdi
callq 0x30850
movq -0x1a8(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: martinda3[P]Compiler/src/TCsymTable.cpp
// Function: toyc::TCsymTable::add(toyc::TCsymbol*)
int TCsymTable::add(TCsymbol *sym) {
        if (size >= MAX_SYMS) {
            std::cerr << "Error: symbol table overflow" << std::endl;
            exit(EXIT_FAILURE);
        } else {
            symTable[size++] = sym;
            return (size - 1);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x64, 0x320(%rax)
jl 0x3180d
movq 0x13808(%rip), %rdi     # 0x44ff0
leaq 0x37a3(%rip), %rsi      # 0x34f92
callq 0x9340
movq %rax, %rdi
movq 0x137b2(%rip), %rsi     # 0x44fb0
callq 0x9380
movl $0x1, %edi
callq 0x9410
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x320(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x320(%rax)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x320(%rax), %eax
subl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: prakhar2808[P]DBEngine/clientCode/client.cc
// Function: sendToServerAndGetResponse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void sendToServerAndGetResponse(std::string data,
                                bool printResponse) {
    memset(buffer, 0, sizeof(buffer));
    strcpy(buffer, data.c_str());
    //unsigned char len = data.length();

    //send(clientSd, &len, 1, 0);
    send(clientSd, buffer, strlen(buffer), 0);
    if(printResponse) {
      std::cout << "Awaiting server response..." 
                << std::endl;
    
      std::cout << "Response from Server: \n";
    }

    if(data == "exit") {
      return;
    }
    
    char bufferSize; //Number of bytes to be read
    while(true){
      memset(buffer, 0, sizeof(buffer));
      // Receiving length of string
      recv(clientSd, &bufferSize, sizeof(bufferSize), 0);
      // Receiving the string
      recv(clientSd, buffer, (int)bufferSize, 0);
      if(strcmp(buffer, "```end```") == 0) {
        break;
      }
      if(printResponse) {
        std::cout << buffer << std::endl;
      }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
leaq 0x32d1(%rip), %rdi      # 0x6270
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2140
movq -0x18(%rbp), %rdi
callq 0x20f0
movq %rax, %rsi
leaq 0x32b2(%rip), %rdi      # 0x6270
callq 0x21f0
movl 0x42a7(%rip), %eax      # 0x7270
movl %eax, -0x10(%rbp)
leaq 0x329d(%rip), %rdi      # 0x6270
callq 0x2110
movl -0x10(%rbp), %edi
movq %rax, %rdx
leaq 0x328b(%rip), %rsi      # 0x6270
xorl %ecx, %ecx
callq 0x2130
testb $0x1, -0x9(%rbp)
je 0x3027
movq 0x2fd7(%rip), %rdi      # 0x5fd0
leaq 0x10f6(%rip), %rsi      # 0x40f6
callq 0x2200
movq %rax, %rdi
movq 0x2fa9(%rip), %rsi      # 0x5fb8
callq 0x2220
movq 0x2fb5(%rip), %rdi      # 0x5fd0
leaq 0x10f0(%rip), %rsi      # 0x4112
callq 0x2200
movq -0x18(%rbp), %rdi
leaq 0x10a5(%rip), %rsi      # 0x40d7
callq 0x3480
testb $0x1, %al
jne 0x303d
jmp 0x3042
jmp 0x30cf
jmp 0x3044
leaq 0x3225(%rip), %rdi      # 0x6270
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2140
movl 0x4213(%rip), %edi      # 0x7270
leaq -0xa(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x20b0
movl 0x41fd(%rip), %edi      # 0x7270
movsbl -0xa(%rbp), %eax
movslq %eax, %rdx
leaq 0x31ef(%rip), %rsi      # 0x6270
xorl %ecx, %ecx
callq 0x20b0
leaq 0x31e1(%rip), %rdi      # 0x6270
leaq 0x1094(%rip), %rsi      # 0x412a
callq 0x2310
cmpl $0x0, %eax
jne 0x30a2
jmp 0x30cf
testb $0x1, -0x9(%rbp)
je 0x30ca
movq 0x2f21(%rip), %rdi      # 0x5fd0
leaq 0x31ba(%rip), %rsi      # 0x6270
callq 0x2200
movq %rax, %rdi
movq 0x2ef3(%rip), %rsi      # 0x5fb8
callq 0x2220
jmp 0x3044
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ricbit[P]dlx/cover_original.cc
// Function: ExactCover::hide(int)
void hide(int p) {
    for (auto q = p + 1; q != p;) {
      auto x = nodes[q].top;
      auto u = nodes[q].ulink;
      auto d = nodes[q].dlink;
      if (x <= 0) {
        q = u;
      } else {
        nodes[u].dlink = d;
        nodes[d].ulink = u;
        nodes[x].top--;
        q++;
      }
    }
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
je 0x7fcc
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4840
movq 0x10(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x24(%rsp)
addq $0x18, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4840
movq 0x10(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x20(%rsp)
addq $0x18, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4840
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x24(%rsp)
jg 0x7f5e
movl 0x20(%rsp), %eax
movl %eax, 0x28(%rsp)
jmp 0x7fc7
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
addq $0x18, %rdi
movslq 0x20(%rsp), %rsi
callq 0x4840
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rdi
movl %ecx, 0x8(%rax)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4840
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rdi
movl %ecx, 0x4(%rax)
addq $0x18, %rdi
movslq 0x24(%rsp), %rsi
callq 0x4840
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x7ef2
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ricbit[P]dlx/cover_original.cc
// Function: ExactCover::unhide(int)
void unhide(int p) {
    for (auto q = p - 1; q != p;) {
      auto x = nodes[q].top;
      auto u = nodes[q].ulink;
      auto d = nodes[q].dlink;
      if (x <= 0) {
        q = d;
      } else {
        nodes[u].dlink = q;
        nodes[d].ulink = q;
        nodes[x].top++;
        q--;
      }
    }
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
je 0x80dc
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4840
movq 0x10(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x24(%rsp)
addq $0x18, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4840
movq 0x10(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x20(%rsp)
addq $0x18, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4840
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x24(%rsp)
jg 0x806e
movl 0x1c(%rsp), %eax
movl %eax, 0x28(%rsp)
jmp 0x80d7
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsp)
addq $0x18, %rdi
movslq 0x20(%rsp), %rsi
callq 0x4840
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rdi
movl %ecx, 0x8(%rax)
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4840
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rdi
movl %ecx, 0x4(%rax)
addq $0x18, %rdi
movslq 0x24(%rsp), %rsi
callq 0x4840
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x28(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x8002
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tylerwowen[P]movielens/./movielens/argparser.cpp
// Function: parse_opt(int, char*, argp_state*)
error_t parse_opt (int key, char *arg, struct argp_state *state) {
  /* Get the input argument from argp_parse, which we
   know is a pointer to our arguments structure. */
  struct arguments *arguments = (struct arguments *)state->input;
  
  switch (key) {
    case 'r':
      arguments->trainFile = arg;
      break;
    case 't':
      arguments->testFile = arg;
      break;
    case 'd':
      arguments->method = atoi(arg);
      break;
    case 'm':
      arguments->moiveNum = atoi(arg);
      break;
    case 'u':
      arguments->userNum = atoi(arg);
      break;
    case 'k':
      arguments->k = atoi(arg);
      break;
    case 'o':
      arguments->matchedOnly = true;
      break;
    case 'p':
      arguments->prettyPrint = true;
      break;
    case 'a':
      arguments->maxRating = atoi(arg);
      break;
    case ARGP_KEY_END:
      if (state->argc < 2) {
        /* No inputs. */
        argp_state_help(state, stdout, ARGP_HELP_STD_HELP);
        exit(0);
      }
      break;
    default:
      return ARGP_ERR_UNKNOWN;
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x61, %eax
je 0x267c
jmp 0x2563
movl 0x4(%rsp), %eax
subl $0x64, %eax
je 0x2608
jmp 0x2572
movl 0x4(%rsp), %eax
subl $0x6b, %eax
je 0x2650
jmp 0x2581
movl 0x4(%rsp), %eax
subl $0x6d, %eax
je 0x2621
jmp 0x2590
movl 0x4(%rsp), %eax
subl $0x6f, %eax
je 0x2666
jmp 0x259f
movl 0x4(%rsp), %eax
subl $0x70, %eax
je 0x2671
jmp 0x25ae
movl 0x4(%rsp), %eax
subl $0x72, %eax
je 0x25e3
jmp 0x25b9
movl 0x4(%rsp), %eax
subl $0x74, %eax
je 0x25f5
jmp 0x25c4
movl 0x4(%rsp), %eax
subl $0x75, %eax
je 0x263a
jmp 0x25cf
movl 0x4(%rsp), %eax
subl $0x1000001, %eax        # imm = 0x1000001
je 0x2692
jmp 0x26bf
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x26c9
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x26c9
movq 0x18(%rsp), %rdi
callq 0x22a0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
jmp 0x26c9
movq 0x18(%rsp), %rdi
callq 0x22a0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rax)
jmp 0x26c9
movq 0x18(%rsp), %rdi
callq 0x22a0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
jmp 0x26c9
movq 0x18(%rsp), %rdi
callq 0x22a0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x26c9
movq 0x8(%rsp), %rax
movb $0x1, 0x24(%rax)
jmp 0x26c9
movq 0x8(%rsp), %rax
movb $0x1, 0x25(%rax)
jmp 0x26c9
movq 0x18(%rsp), %rdi
callq 0x22a0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
jmp 0x26c9
movq 0x10(%rsp), %rax
cmpl $0x2, 0x8(%rax)
jge 0x26bd
movq 0x10(%rsp), %rdi
movq 0x158ff(%rip), %rax     # 0x17fa8
movq (%rax), %rsi
movl $0x27a, %edx            # imm = 0x27A
callq 0x2090
xorl %edi, %edi
callq 0x2210
jmp 0x26c9
movl $0x7, 0x24(%rsp)
jmp 0x26d1
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tylerwowen[P]movielens/./movielens/main.cpp
// Function: getPredication(std::vector<Ratings*, std::allocator<Ratings*>>, int)
double getPredication(UsersPtr neighbors, int itemId) {
  int validRatings = 0;
  double ratingSum = 0;
  for (int i = 0; i < neighbors.size(); i++) {
    Ratings_map::const_iterator ratingItr = neighbors[i]->r_map.find(itemId);
    if (ratingItr != neighbors[i]->r_map.end()) {
      validRatings++;
      ratingSum += ratingItr->second;
    }
  }
  if (validRatings == 0) {
    return 0;
  }
  return ratingSum/validRatings;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movl $0x0, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x34(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x8000
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x72d1
movq 0x10(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x8020
movq (%rax), %rdi
addq $0x18, %rdi
leaq 0x44(%rsp), %rsi
callq 0x8040
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x8070
movq 0x10(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x8020
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x80c0
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x80a0
testb $0x1, %al
jne 0x7299
jmp 0x72bf
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x80f0
movsd 0x8(%rax), %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
jmp 0x72c1
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x720b
cmpl $0x0, 0x40(%rsp)
jne 0x72e3
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x72f9
movsd 0x38(%rsp), %xmm0
cvtsi2sdl 0x40(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tylerwowen[P]movielens/./movielens/neighborsfinder.cpp
// Function: NeighborsLocator::NeighborsLocator(std::unordered_map<int, Ratings, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, Ratings>>>*, int, int, int, int)
NeighborsLocator::NeighborsLocator(UsersMap *trainUsers, int numOfItems, int k, int method, int maxRating) {
  this->trainUsers = trainUsers;
  this->numOfItems = numOfItems;
  this->k = k;
  this->method = method;
  this->maxRating = maxRating;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movl %r9d, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x28, %rdi
callq 0xbc20
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x10(%rsp), %ecx
movl %ecx, 0xc(%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0x10(%rax)
movl 0x8(%rsp), %ecx
movl %ecx, 0x14(%rax)
addq $0x28, %rsp
retq
nop
// File: tylerwowen[P]movielens/./movielens/neighborsfinder.cpp
// Function: NeighborsLocator::calculateSortableAllDistances(std::vector<std::pair<int, double>, std::allocator<std::pair<int, double>>>&, double (NeighborsLocator::*)(std::__cxx11::list<std::pair<int, double>, std::allocator<std::pair<int, double>>>&, std::__cxx11::list<std::pair<int, double>, std::allocator<std::pair<int, double>>>&))
void NeighborsLocator::calculateSortableAllDistances(Distances &distances, double (NeighborsLocator::*distanceFunc)(Ratings_list&, Ratings_list&)) {
  int i = 0;
  for (auto& otherUser: *trainUsers) {
    distances[i].first = otherUser.first;
    distances[i].second = (this->*distanceFunc)(otherUser.second.r_list, targetUserRatings->r_list);
    i++;
  }
}

// Assembly:
subq $0x88, %rsp
movq %rdx, 0x78(%rsp)
movq %rcx, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq 0x80(%rsp), %rcx
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq %rax, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x54(%rsp)
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x5670
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x56a0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x56d0
testb $0x1, %al
jne 0x9905
jmp 0x99d6
leaq 0x40(%rsp), %rdi
callq 0x56f0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x68(%rsp), %rdi
movslq 0x54(%rsp), %rsi
callq 0xbd70
movl 0x14(%rsp), %edx
movq 0x28(%rsp), %rcx
movl %edx, (%rax)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rsp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0x9976
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, 0x8(%rsp)
jmp 0x9980
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rsi
addq $0x8, %rsi
movq 0x20(%rcx), %rdx
callq *%rax
movsd %xmm0, (%rsp)
movq 0x68(%rsp), %rdi
movslq 0x54(%rsp), %rsi
callq 0xbd70
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5710
jmp 0x98ed
addq $0x88, %rsp
retq
nop
// File: tylerwowen[P]movielens/./movielens/neighborsfinder.cpp
// Function: sort_nth_elemet(std::vector<std::pair<int, double>, std::allocator<std::pair<int, double>>>&, int, bool)
void sort_nth_elemet(Distances &distances, int k, bool ascending) {
  if (ascending) {
    nth_element(distances.begin(), distances.begin() + k, distances.end(), cmp);
    sort(distances.begin(), distances.begin() + k, cmp);
  }
  else {
    nth_element(distances.begin(), distances.begin() + k, distances.end(), reverseCmp);
    sort(distances.begin(), distances.begin() + k, reverseCmp);
  }
}

// Assembly:
subq $0x88, %rsp
movb %dl, %al
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
andb $0x1, %al
movb %al, 0x7b(%rsp)
testb $0x1, 0x7b(%rsp)
je 0xa00e
movq 0x80(%rsp), %rdi
callq 0xc310
movq %rax, 0x70(%rsp)
movq 0x80(%rsp), %rdi
callq 0xc310
movq %rax, 0x60(%rsp)
movslq 0x7c(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0xc340
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rdi
callq 0xc380
movq %rax, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x58(%rsp), %rdx
leaq 0x1c0a(%rip), %rcx      # 0xbbc0
callq 0xc260
movq 0x80(%rsp), %rdi
callq 0xc310
movq %rax, 0x50(%rsp)
movq 0x80(%rsp), %rdi
callq 0xc310
movq %rax, 0x40(%rsp)
movslq 0x7c(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0xc340
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x1bbc(%rip), %rdx      # 0xbbc0
callq 0xc3b0
jmp 0xa0c1
movq 0x80(%rsp), %rdi
callq 0xc310
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rdi
callq 0xc310
movq %rax, 0x28(%rsp)
movslq 0x7c(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xc340
movq %rax, 0x30(%rsp)
movq 0x80(%rsp), %rdi
callq 0xc380
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x1b82(%rip), %rcx      # 0xbbf0
callq 0xc260
movq 0x80(%rsp), %rdi
callq 0xc310
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rdi
callq 0xc310
movq %rax, 0x8(%rsp)
movslq 0x7c(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xc340
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x1b34(%rip), %rdx      # 0xbbf0
callq 0xc3b0
addq $0x88, %rsp
retq
nopl (%rax)
// File: tylerwowen[P]movielens/./movielens/neighborsfinder.cpp
// Function: NeighborsLocator::calculateDistancesToNeighbors(int)
void NeighborsLocator::calculateDistancesToNeighbors(int numUsers) {
  cachedDistances.assign(numUsers + 1, 0.0);
  switch (method) {
    case COS:
      calculateAllDistances(&NeighborsLocator::cosineSimilarity);
      break;
    case L1:
      calculateAllDistances(&NeighborsLocator::cityBlockDistance);
      break;
    case L2:
      calculateAllDistances(&NeighborsLocator::euclideanDistance);
      break;
    case PCC:
      calculateAllDistances(&NeighborsLocator::pcc);
      break;
    case LLR:
      calculateAllDistances(&NeighborsLocator::llr);
      break;
    default:
      break;
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x28, %rdi
movl 0x6c(%rsp), %eax
incl %eax
movslq %eax, %rsi
movq $0x0, 0x60(%rsp)
leaq 0x60(%rsp), %rdx
callq 0xbdf0
movq (%rsp), %rax
movl 0x10(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x4, %rax
ja 0xb6d9
movq 0x8(%rsp), %rax
leaq 0x5bf4(%rip), %rcx      # 0x111ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rdi
leaq -0x1c2c(%rip), %rax     # 0x99e0
movq %rax, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xb6e0
jmp 0xb6db
movq (%rsp), %rdi
leaq -0x1569(%rip), %rax     # 0xa0d0
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0xb6e0
jmp 0xb6db
movq (%rsp), %rdi
leaq -0x1146(%rip), %rax     # 0xa520
movq %rax, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0xb6e0
jmp 0xb6db
movq (%rsp), %rdi
leaq -0xd20(%rip), %rax      # 0xa970
movq %rax, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xb6e0
jmp 0xb6db
movq (%rsp), %rdi
leaq -0x6ca(%rip), %rax      # 0xaff0
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xb6e0
jmp 0xb6db
jmp 0xb6db
addq $0x78, %rsp
retq
// File: tylerwowen[P]movielens/./movielens/neighborsfinder.cpp
// Function: NeighborsLocator::calculateDistances(std::vector<std::pair<int, double>, std::allocator<std::pair<int, double>>>&)
void NeighborsLocator::calculateDistances(Distances &distances) {
  for (auto& otherUser: *trainUsers) {
    Ratings_map *ratings = &otherUser.second.r_map;
    Ratings_map::const_iterator ratingItr = ratings->find(targetItemId);
    if (ratingItr != ratings->end()) {
      distances.push_back({otherUser.first, cachedDistances[otherUser.first]});
    }
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x5670
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x56a0
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x56d0
testb $0x1, %al
jne 0xbad6
jmp 0xbb9c
leaq 0x58(%rsp), %rdi
callq 0x56f0
movq 0x10(%rsp), %rsi
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
addq $0x8, %rax
addq $0x18, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
addq $0x40, %rsi
callq 0x8040
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x8070
movq 0x40(%rsp), %rdi
callq 0x80c0
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x80a0
testb $0x1, %al
jne 0xbb42
jmp 0xbb8b
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
addq $0x28, %rdi
movq 0x48(%rsp), %rax
movslq (%rax), %rsi
callq 0xbfa0
movq (%rsp), %rsi
movq %rax, %rdx
leaq 0x18(%rsp), %rdi
callq 0xbff0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xbfc0
jmp 0xbb8d
leaq 0x58(%rsp), %rdi
callq 0x5710
jmp 0xbabe
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Detail::Approx::equalityComparisonImpl(double) const
bool Approx::equalityComparisonImpl(const double other) const {
        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
        // Thanks to Richard Harris for his help refining the scaled margin value
        return marginComparison(m_value, other, m_margin)
            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd 0x18(%rax), %xmm0
movsd -0x10(%rbp), %xmm1
movsd 0x8(%rax), %xmm2
callq 0x53c70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x53c64
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x18(%rax), %xmm0
callq 0x8abc0
testb $0x1, %al
jne 0x53c18
jmp 0x53c22
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x53c30
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
movsd -0x48(%rbp), %xmm4
movaps 0xe93d0(%rip), %xmm5    # 0x13d020
pand %xmm5, %xmm4
addsd %xmm4, %xmm3
mulsd %xmm3, %xmm2
callq 0x53c70
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Detail::Approx::setMargin(double)
void Approx::setMargin(double newMargin) {
        CATCH_ENFORCE(newMargin >= 0,
            "Invalid Approx::margin: " << newMargin << '.'
            << " Approx::Margin has to be non-negative.");
        m_margin = newMargin;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x53d9f
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x67d90
movq -0x70(%rbp), %rdi
leaq 0xeaafa(%rip), %rsi     # 0x13e800
callq 0x8ac00
movq %rax, -0x68(%rbp)
jmp 0x53d11
movq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x8ac30
movq %rax, -0x78(%rbp)
jmp 0x53d24
movq -0x78(%rbp), %rdi
movb $0x2e, -0x55(%rbp)
leaq -0x55(%rbp), %rsi
callq 0x8ac70
movq %rax, -0x80(%rbp)
jmp 0x53d3b
movq -0x80(%rbp), %rdi
leaq 0xeaad3(%rip), %rsi     # 0x13e819
callq 0x8acb0
movq %rax, -0x88(%rbp)
jmp 0x53d54
movq -0x88(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x53b70
jmp 0x53d66
leaq -0x30(%rbp), %rdi
callq 0x53dd0
jmp 0x53d71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x53d94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52e58
leaq -0x48(%rbp), %rdi
callq 0x67e50
jmp 0x53db8
jmp 0x53da1
movq -0x60(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Detail::Approx::setEpsilon(double)
void Approx::setEpsilon(double newEpsilon) {
        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
            "Invalid Approx::epsilon: " << newEpsilon << '.'
            << " Approx::epsilon has to be in [0, 1]");
        m_epsilon = newEpsilon;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x53e5d
movsd 0xe920e(%rip), %xmm0    # 0x13d060
ucomisd -0x10(%rbp), %xmm0
jae 0x53f0e
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x67d90
movq -0x70(%rbp), %rdi
leaq 0xea9cc(%rip), %rsi     # 0x13e841
callq 0x8ace0
movq %rax, -0x68(%rbp)
jmp 0x53e80
movq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x8ac30
movq %rax, -0x78(%rbp)
jmp 0x53e93
movq -0x78(%rbp), %rdi
movb $0x2e, -0x55(%rbp)
leaq -0x55(%rbp), %rsi
callq 0x8ac70
movq %rax, -0x80(%rbp)
jmp 0x53eaa
movq -0x80(%rbp), %rdi
leaq 0xea9a6(%rip), %rsi     # 0x13e85b
callq 0x8ad10
movq %rax, -0x88(%rbp)
jmp 0x53ec3
movq -0x88(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x53b70
jmp 0x53ed5
leaq -0x30(%rbp), %rdi
callq 0x53dd0
jmp 0x53ee0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x53f03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52e58
leaq -0x48(%rbp), %rdi
callq 0x67e50
jmp 0x53f26
jmp 0x53f10
movq -0x60(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x52c90
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::operator<<(std::ostream&, Catch::LazyExpression const&)
auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
        if( lazyExpr.m_isNegated )
            os << "!";

        if( lazyExpr ) {
            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
                os << "(" << *lazyExpr.m_transientExpression << ")";
            else
                os << *lazyExpr.m_transientExpression;
        }
        else {
            os << "{** error - unchecked empty expression requested **}";
        }
        return os;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x5406a
movq -0x8(%rbp), %rdi
leaq 0xeb630(%rip), %rsi     # 0x13f695
callq 0x52710
movq -0x10(%rbp), %rdi
callq 0x54020
testb $0x1, %al
jne 0x54079
jmp 0x540d7
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x540c5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x8adc0
testb $0x1, %al
jne 0x54095
jmp 0x540c5
movq -0x8(%rbp), %rdi
leaq 0xebc3c(%rip), %rsi     # 0x13fcdc
callq 0x52710
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x54100
movq %rax, %rdi
leaq 0xea740(%rip), %rsi     # 0x13e7fe
callq 0x52710
jmp 0x540d5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x54100
jmp 0x540e7
movq -0x8(%rbp), %rdi
leaq 0xea79e(%rip), %rsi     # 0x13e880
callq 0x52710
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::getResultCapture()
IResultCapture& getResultCapture() {
        if (auto* capture = getCurrentContext().getResultCapture())
            return *capture;
        else
            CATCH_INTERNAL_ERROR("No result capture instance");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
callq 0x8ae00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x541f1
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x67d90
leaq 0xeadcc(%rip), %rsi     # 0x13efd1
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x335d, %edx           # imm = 0x335D
callq 0x8e600
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x8e5d0
movq %rax, -0x68(%rbp)
jmp 0x5422a
movq -0x68(%rbp), %rdi
leaq 0xeb071(%rip), %rsi     # 0x13f2a6
callq 0x8ace0
movq %rax, -0x80(%rbp)
jmp 0x54240
movq -0x80(%rbp), %rdi
leaq 0xeb3dc(%rip), %rsi     # 0x13f627
callq 0x8fe90
movq %rax, -0x88(%rbp)
jmp 0x54259
movq -0x88(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x53b70
jmp 0x5426b
leaq -0x28(%rbp), %rdi
callq 0x5b700
jmp 0x54276
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x54299
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x52e58
leaq -0x40(%rbp), %rdi
callq 0x67e50
movq -0x58(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::AssertionHandler::complete()
void AssertionHandler::complete() {
        setCompleted();
        if( m_reaction.shouldDebugBreak ) {

            // If you find your debugger stopping you here then go one level up on the
            // call-stack for the code that caused it (typically a failed assertion)

            // (To go back to the test and change execution, jump over the throw, next)
            CATCH_BREAK_INTO_DEBUGGER();
        }
        if (m_reaction.shouldThrow) {
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
            throw Catch::TestFailureException();
#else
            CATCH_ERROR( "Test failure requires aborting test!" );
#endif
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x543c0
movq -0x18(%rbp), %rax
testb $0x1, 0x38(%rax)
je 0x5438c
leaq -0x9(%rbp), %rdi
callq 0x543e0
movq -0x18(%rbp), %rax
testb $0x1, 0x39(%rax)
je 0x543b3
movl $0x1, %edi
callq 0x52380
movq %rax, %rdi
leaq 0x168596(%rip), %rsi    # 0x1bc940
xorl %eax, %eax
movl %eax, %edx
callq 0x52c20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::AssertionResultData::reconstructExpression[abi:cxx11]() const
std::string AssertionResultData::reconstructExpression() const {

        if( reconstructedExpression.empty() ) {
            if( lazyExpression ) {
                ReusableStringStream rss;
                rss << lazyExpression;
                reconstructedExpression = rss.str();
            }
        }
        return reconstructedExpression;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x20, %rdi
callq 0x52bb0
testb $0x1, %al
jne 0x54808
jmp 0x54888
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
callq 0x54020
testb $0x1, %al
jne 0x5481b
jmp 0x54886
leaq -0x28(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x67d90
movq -0x60(%rbp), %rsi
movq -0x78(%rbp), %rdi
addq $0x40, %rsi
callq 0x8ae50
jmp 0x5483b
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x53b70
jmp 0x5484a
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
leaq -0x58(%rbp), %rsi
callq 0x528a0
leaq -0x58(%rbp), %rdi
callq 0x52e58
leaq -0x28(%rbp), %rdi
callq 0x67e50
jmp 0x54886
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x67e50
jmp 0x548a6
jmp 0x54888
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %rsi
addq $0x20, %rsi
callq 0x52300
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x52c90
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::AssertionResult::getExpression[abi:cxx11]() const
std::string AssertionResult::getExpression() const {
        // Possibly overallocating by 3 characters should be basically free
        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
        if (isFalseTest(m_info.resultDisposition)) {
            expr += "!(";
        }
        expr += m_info.capturedExpression;
        if (isFalseTest(m_info.resultDisposition)) {
            expr += ')';
        }
        return expr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%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 0x52a00
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x8af50
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x3, %rsi
callq 0x52ae0
jmp 0x54a8b
movq -0x38(%rbp), %rax
movl 0x30(%rax), %edi
callq 0x8af70
movb %al, -0x41(%rbp)
jmp 0x54a9c
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x54aa5
jmp 0x54ad0
movq -0x30(%rbp), %rdi
leaq 0xe9e05(%rip), %rsi     # 0x13e8b5
callq 0x526e0
jmp 0x54ab7
jmp 0x54ad0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x52e58
jmp 0x54b2c
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x20, %rsi
callq 0x54b40
jmp 0x54ae3
movq -0x38(%rbp), %rax
movl 0x30(%rax), %edi
callq 0x8af70
movb %al, -0x42(%rbp)
jmp 0x54af4
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x54afd
jmp 0x54b0f
movq -0x30(%rbp), %rdi
movl $0x29, %esi
callq 0x52470
jmp 0x54b0d
jmp 0x54b0f
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x54b22
movq -0x30(%rbp), %rdi
callq 0x52e58
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::AssertionResult::getExpressionInMacro[abi:cxx11]() const
std::string AssertionResult::getExpressionInMacro() const {
        std::string expr;
        if( m_info.macroName.empty() )
            expr = static_cast<std::string>(m_info.capturedExpression);
        else {
            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
            expr += m_info.macroName;
            expr += "( ";
            expr += m_info.capturedExpression;
            expr += " )";
        }
        return expr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x52a00
movq -0x50(%rbp), %rdi
callq 0x8af30
testb $0x1, %al
jne 0x54bcb
jmp 0x54c13
movq -0x50(%rbp), %rsi
addq $0x20, %rsi
leaq -0x38(%rbp), %rdi
callq 0x8af90
jmp 0x54bde
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x528a0
leaq -0x38(%rbp), %rdi
callq 0x52e58
jmp 0x54c8c
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x52e58
jmp 0x54ca9
movq -0x50(%rbp), %rdi
callq 0x8af50
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
addq $0x20, %rdi
callq 0x8af50
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movq -0x68(%rbp), %rax
leaq 0x4(%rax,%rcx), %rsi
callq 0x52ae0
jmp 0x54c44
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x54b40
jmp 0x54c53
movq -0x60(%rbp), %rdi
leaq 0xe9b9c(%rip), %rsi     # 0x13e7fa
callq 0x526e0
jmp 0x54c65
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x20, %rsi
callq 0x54b40
jmp 0x54c78
movq -0x60(%rbp), %rdi
leaq 0xe9b7a(%rip), %rsi     # 0x13e7fd
callq 0x526e0
jmp 0x54c8a
jmp 0x54c8c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x54c9f
movq -0x60(%rbp), %rdi
callq 0x52e58
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::AssertionResult::getExpandedExpression[abi:cxx11]() const
std::string AssertionResult::getExpandedExpression() const {
        std::string expr = m_resultData.reconstructExpression();
        return expr.empty()
                ? getExpression()
                : expr;
    }

// 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)
addq $0x38, %rsi
leaq -0x30(%rbp), %rdi
callq 0x547d0
leaq -0x30(%rbp), %rdi
callq 0x52bb0
testb $0x1, %al
jne 0x54dbf
jmp 0x54dd0
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x54a40
jmp 0x54dce
jmp 0x54de1
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x52300
jmp 0x54ddf
jmp 0x54de1
leaq -0x30(%rbp), %rdi
callq 0x52e58
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52e58
movq -0x38(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)