LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/main.cpp
// Function: main
int main(int argc, char** argv)
{
    /* set the RV data file */
    datafile = "examples/BL2009/BL2009_dataset1.kms.rv";

    /* load the file (RVs are in km/s) */
    /* don't skip any lines in the header */
    Data::get_instance().load(datafile, "kms", 0);

    // set the sampler and run it!
    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x6f8, %rsp            # imm = 0x6F8
movq %rsi, %rbx
movl %edi, %ebp
movq 0x30157(%rip), %rdx     # 0x50550
leaq 0x30148(%rip), %rdi     # 0x50548
leaq 0x22666(%rip), %rcx     # 0x42a6d
movl $0x26, %r8d
xorl %esi, %esi
callq 0x6600
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x30124(%rip), %rsi     # 0x50548
movq 0x30125(%rip), %rdx     # 0x50550
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xae5c
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ce08(%rip), %rsi     # 0x3d250
leaq 0x1ce04(%rip), %rdx     # 0x3d253
movq %rsp, %rdi
callq 0x17f6a
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r8
movaps %xmm0, (%r8)
movq $0x0, 0x10(%r8)
leaq 0x2ff8e(%rip), %rdi     # 0x50400
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
xorl %ecx, %ecx
callq 0x81f6
leaq 0x40(%rsp), %rdi
callq 0xad64
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x204a1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6460
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x204b8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6460
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x206f3
movq %r14, %rdi
movl $0x32, %esi
callq 0x207c4
leaq 0x40(%rsp), %rdi
callq 0x209a2
xorl %eax, %eax
addq $0x6f8, %rsp            # imm = 0x6F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x209a2
jmp 0x2053f
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xad64
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x20528
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6460
jmp 0x20528
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x2053f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6460
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/mshcompare/mshcompare.cpp
// Function: ReadMesh(char*)
static R3Mesh *
ReadMesh(char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate mesh
  R3Mesh *mesh = new R3Mesh();
  if (!mesh) {
    RNFail("Unable to allocate mesh for %s\n", filename);
    return NULL;
  }

  // Read mesh from file
  if (!mesh->ReadFile(filename)) {
    delete mesh;
    return NULL;
  }

  // Print statistics
  if (print_verbose) {
    printf("Read mesh from %s\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return success
  return mesh;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x566f0
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc5c0
movl $0x138, %edi            # imm = 0x138
callq 0xc390
movq %rax, %rbx
movq %rax, %rdi
callq 0x21af8
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x180(%rax)
testl %eax, %eax
je 0xf597
cmpb $0x1, 0x70588(%rip)     # 0x7fab0
jne 0xf5a2
leaq 0x49b44(%rip), %rdi     # 0x59075
movq %r14, %rsi
xorl %eax, %eax
callq 0xc070
leaq 0x8(%rsp), %rdi
callq 0x56752
leaq 0x49b3c(%rip), %rdi     # 0x59088
movb $0x1, %al
callq 0xc070
movl 0x34(%rbx), %esi
leaq 0x49b42(%rip), %rdi     # 0x5909f
xorl %eax, %eax
callq 0xc070
movl 0x24(%rbx), %esi
leaq 0x49b41(%rip), %rdi     # 0x590af
xorl %eax, %eax
callq 0xc070
movl 0x14(%rbx), %esi
leaq 0x49b40(%rip), %rdi     # 0x590bf
xorl %eax, %eax
callq 0xc070
movq 0x6f9fb(%rip), %rax     # 0x7ef88
movq (%rax), %rdi
callq 0xc440
jmp 0xf5a2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x138, %esi            # imm = 0x138
movq %rbx, %rdi
callq 0xc3a0
movq %r14, %rdi
callq 0xc640
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/vividvilla[P]hackerrank/src/quicksort1.cpp
// Function: partition(std::vector<int, std::allocator<int>>)
vector<int> partition(vector<int> ar) {
    int N = ar.size();

    int p = ar[0];
    vector<int> p1;
    vector<int> p2;
    for (int i = 0; i < N; i++) {
        if (ar[i] < p)
            p1.push_back(ar[i]);
        else if (ar[i] > p)
            p2.push_back(ar[i]);
    }
    p1.push_back(p);
    p1.insert(p1.end(), p2.begin(), p2.end());

    return p1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %r15
subq %rax, %r15
shrq $0x2, %r15
movl (%rax), %ebp
movl %ebp, 0x24(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rax, 0x10(%rsp)
movaps %xmm0, (%rsp)
testl %r15d, %r15d
jle 0x1312
movq %rsi, %r14
leaq 0x8(%rbx), %r13
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq (%r14), %rdx
movl (%rdx,%r12), %eax
cmpl %ebp, %eax
jge 0x12d2
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r13, %rcx
cmpq 0x10(%rbx), %rsi
je 0x12e8
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, (%rcx)
jmp 0x12f0
jle 0x12f0
movq 0x8(%rsp), %rsi
movq %rsp, %rdi
leaq 0x8(%rsp), %rcx
cmpq 0x10(%rsp), %rsi
jne 0x12c7
addq %r12, %rdx
callq 0x15da
addq $0x4, %r12
decq %r15
jne 0x12ac
leaq 0x8(%rbx), %r14
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1318
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, (%r14)
jmp 0x1328
leaq 0x8(%rbx), %r14
xorl %esi, %esi
leaq 0x24(%rsp), %rdx
movq %rbx, %rdi
callq 0x15da
movq (%r14), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x1716
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x134f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1365
jmp 0x1365
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x137e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1392
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %r14, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O3/vividvilla[P]hackerrank/src/quicksort1.cpp
// Function: main
int main() {
    int n, x;
    cin >> n;

    vector<int> ar;
    for (int i = 0; i < n; i++) {
        cin >> x;
        ar.push_back(x);
    }

    vector<int> p = partition(ar);
    for (int i = 0; i < n; i++) {
        cout << p[i];
        if (i + 1 < n)
            cout << " ";
        else
            cout << endl;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0x2c35(%rip), %rdi      # 0x3fe0
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x1060
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x0, (%rbx)
jle 0x141c
xorl %ebp, %ebp
movq 0x2c09(%rip), %rbx      # 0x3fe0
leaq 0xc(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1060
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x1409
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x1414
movq %r15, %rdi
movq %r14, %rdx
callq 0x15da
incl %ebp
cmpl 0x8(%rsp), %ebp
jl 0x13e1
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x155a
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x125c
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1451
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
cmpl $0x0, 0x8(%rsp)
jle 0x14ca
xorl %r15d, %r15d
movq 0x2b6e(%rip), %rbx      # 0x3fd0
leaq 0xb9b(%rip), %r14       # 0x2004
movq 0x40(%rsp), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x1100
incq %r15
movslq 0x8(%rsp), %rax
cmpq %rax, %r15
jge 0x1499
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10d0
jmp 0x14c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movslq 0x8(%rsp), %rax
cmpq %rax, %r15
jl 0x1469
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x14e1
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14f8
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x153a
movq 0x38(%rsp), %rsi
jmp 0x1532
jmp 0x151b
movq %rax, %rbx
jmp 0x153a
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x153a
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1551
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1110
nop
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/ChiSquareExperiments/VaryMemoryReal.cpp
// Function: name_file(char*, char**, int)
void name_file(char *str, char* argv[], int extra)
{
  time_t now = time(0);
  struct tm tstruct;
  char buf[80];
  tstruct = *localtime(&now);
  strftime(buf, sizeof(buf), "%m-%d-%Y.%X", &tstruct);

  strcpy(str, "RealContinuous_");
  strcat(str, argv[1]);
  strcat(str, "-");
  strcat(str, argv[2]);
  strcat(str, "_");
  strcat(str, argv[3]);
  strcat(str, "_");
  strcat(str, argv[5]);
  strcat(str, "_");
  strcat(str, buf);

  if (extra == 0)
  strcat(str, "_log.dat");
 else if (extra == 1)
   strcat(str, "_table.dat");
 else if (extra == 2)
   strcat(str, "_extra.dat");
 else 
   strcat(str, "_pvalues.dat");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
xorl %edi, %edi
callq 0x2200
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
callq 0x2190
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq -0x70(%rbp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rcx)
leaq 0x2849(%rip), %rdx      # 0x839a
leaq -0xc0(%rbp), %r12
movl $0x50, %esi
movq %r12, %rdi
callq 0x21d0
movups 0x283a(%rip), %xmm0     # 0x83a6
movups %xmm0, (%r14)
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x23c0
movq %r14, %rdi
callq 0x2100
movw $0x2d, (%r14,%rax)
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x23c0
movq %r14, %rdi
callq 0x2100
movw $0x5f, %r13w
movw %r13w, (%r14,%rax)
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x23c0
movq %r14, %rdi
callq 0x2100
movw %r13w, (%r14,%rax)
movq 0x28(%r15), %rsi
movq %r14, %rdi
callq 0x23c0
movq %r14, %rdi
callq 0x2100
movw %r13w, (%r14,%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x23c0
movq %r14, %rdi
callq 0x2100
addq %r14, %rax
cmpl $0x2, %ebx
je 0x5c1e
cmpl $0x1, %ebx
je 0x5c12
testl %ebx, %ebx
jne 0x5c34
movabsq $0x7461642e676f6c5f, %rcx # imm = 0x7461642E676F6C5F
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
jmp 0x5c4f
movabsq $0x642e656c6261745f, %rcx # imm = 0x642E656C6261745F
jmp 0x5c28
movabsq $0x642e61727478655f, %rcx # imm = 0x642E61727478655F
movq %rcx, (%rax)
movl $0x746164, 0x7(%rax)    # imm = 0x746164
jmp 0x5c4f
movabsq $0x7461642e736575, %rcx # imm = 0x7461642E736575
movq %rcx, 0x5(%rax)
movabsq $0x7365756c6176705f, %rcx # imm = 0x7365756C6176705F
movq %rcx, (%rax)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bluesky466[P]ResourcesParser/main.cpp
// Function: getArgv(char const*, char**, int)
int findArgvIndex(const char* argv, char *argvs[], int count) {
	for(int i = 0 ; i<count ; i++) {
		if(strcmp(argv, argvs[i])==0) {
			return i;
		}
	}
	return -1;
}

// Assembly:
testl %edx, %edx
jle 0x3b50
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %r12
movl %edx, %ebx
negq %rbx
movl $0x1, %r13d
movq -0x8(%r14,%r13,8), %rsi
movq %r12, %rdi
callq 0x3270
testl %eax, %eax
je 0x3b53
leaq (%rbx,%r13), %rax
incq %rax
incq %r13
cmpq $0x1, %rax
jne 0x3b2d
jmp 0x3b5e
xorl %eax, %eax
retq
cmpl %r15d, %r13d
jge 0x3b5e
movq (%r14,%r13,8), %rax
jmp 0x3b60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/bluesky466[P]ResourcesParser/main.cpp
// Function: printHelp()
void printHelp() {
	cout <<"rp -p path [-a] [-t type] [-i id]" <<endl<<endl;
	cout <<"-p : set path of resources.arsc" <<endl;
	cout <<"-a : show all of resources.arsc" <<endl;
	cout <<"-t : select the type in resources.arsc to show" <<endl;
	cout <<"-i : select the id of resource to show" <<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xb40a(%rip), %rbx      # 0xefd8
leaq 0x743b(%rip), %rsi      # 0xb010
movl $0x21, %edx
movq %rbx, %rdi
callq 0x3220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3120
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3120
leaq 0x73f8(%rip), %rsi      # 0xb032
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x3220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3120
leaq 0x73dd(%rip), %rsi      # 0xb052
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x3220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3120
leaq 0x73c2(%rip), %rsi      # 0xb072
movl $0x2e, %edx
movq %rbx, %rdi
callq 0x3220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3120
leaq 0x73b6(%rip), %rsi      # 0xb0a1
movl $0x26, %edx
movq %rbx, %rdi
callq 0x3220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3120
nop
// File: /workspace/github_cpp_makefile_star2_O3/bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: stringOfComplex[abi:cxx11](unsigned int, bool)
static string stringOfComplex(uint32_t complex, bool isFraction) {
	stringstream ss;
    const float MANTISSA_MULT =
        1.0f / (1<<Res_value::COMPLEX_MANTISSA_SHIFT);
    const float RADIX_MULTS[] = {
        1.0f*MANTISSA_MULT, 1.0f/(1<<7)*MANTISSA_MULT,
        1.0f/(1<<15)*MANTISSA_MULT, 1.0f/(1<<23)*MANTISSA_MULT
    };

    float value = (complex&(Res_value::COMPLEX_MANTISSA_MASK
                   <<Res_value::COMPLEX_MANTISSA_SHIFT))
            * RADIX_MULTS[(complex>>Res_value::COMPLEX_RADIX_SHIFT)
                            & Res_value::COMPLEX_RADIX_MASK];
	ss<<value;

    if (!isFraction) {
        switch ((complex>>Res_value::COMPLEX_UNIT_SHIFT)&Res_value::COMPLEX_UNIT_MASK) {
            case Res_value::COMPLEX_UNIT_PX: ss<<"px"; break;
            case Res_value::COMPLEX_UNIT_DIP: ss<<"dp"; break;
            case Res_value::COMPLEX_UNIT_SP: ss<<"sp"; break;
            case Res_value::COMPLEX_UNIT_PT: ss<<"pt"; break;
            case Res_value::COMPLEX_UNIT_IN: ss<<"in"; break;
            case Res_value::COMPLEX_UNIT_MM: ss<<"mm"; break;
            default: ss<<" (unknown unit)"; break;
        }
    } else {
        switch ((complex>>Res_value::COMPLEX_UNIT_SHIFT)&Res_value::COMPLEX_UNIT_MASK) {
            case Res_value::COMPLEX_UNIT_FRACTION: ss<<"%"; break;
            case Res_value::COMPLEX_UNIT_FRACTION_PARENT: ss<<"%p"; break;
            default: ss<<" (unknown unit)"; break;
        }
    }
	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x3140
movl %r15d, %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
cvtsi2ss %rax, %xmm0
movl %r15d, %eax
shrl $0x2, %eax
andl $0xc, %eax
leaq 0x4ddd(%rip), %rcx      # 0xb1f0
mulss (%rax,%rcx), %xmm0
leaq -0x198(%rbp), %r14
cvtss2sd %xmm0, %xmm0
movq %r14, %rdi
callq 0x32c0
andl $0xf, %r15d
testb %r12b, %r12b
je 0x644d
testl %r15d, %r15d
je 0x6479
cmpl $0x1, %r15d
jne 0x646b
movl $0x2, %edx
leaq 0x4f99(%rip), %rsi      # 0xb3e4
jmp 0x6485
cmpl $0x6, %r15d
jae 0x646b
movl %r15d, %eax
leaq 0x4d6b(%rip), %rcx      # 0xb1c8
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movl $0x2, %edx
jmp 0x6485
movl $0xf, %edx
leaq 0x4f5b(%rip), %rsi      # 0xb3d2
jmp 0x6485
movl $0x1, %edx
leaq 0x4f5d(%rip), %rsi      # 0xb3e2
movq %r14, %rdi
callq 0x3220
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x32b0
movq 0x8b05(%rip), %rsi      # 0xefa8
leaq -0x1a8(%rbp), %rdi
callq 0x3160
leaq -0x128(%rbp), %rdi
callq 0x30b0
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8ad3(%rip), %rsi      # 0xefa8
leaq -0x1a8(%rbp), %rdi
callq 0x3160
leaq -0x128(%rbp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O3/bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: ResourcesParser::getStringFromResStringPool[abi:cxx11](std::shared_ptr<ResourcesParser::ResStringPool>, unsigned int)
string ResourcesParser::getStringFromResStringPool(
			ResourcesParser::ResStringPoolPtr pPool,
			uint32_t index) {
	if(index > pPool->header.stringCount) {
		return "???";
	}
	uint32_t offset = *(pPool->pOffsets.get() + index);
	//前两个字节是字符串长度
	char* str = ((char*) (pPool->pStrings.get() + offset + 2));
	return (pPool->header.flags & ResStringPool_header::UTF8_FLAG)
		? str
		: toUtf8((char16_t*) str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
cmpl %edx, 0x8(%rax)
jae 0x6f44
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x439f(%rip), %rsi      # 0xb2d4
leaq 0x439b(%rip), %rdx      # 0xb2d7
movq %rbx, %rdi
jmp 0x702f
movl %edx, %ecx
movq 0x20(%rax), %rsi
movq 0x30(%rax), %rdx
movl (%rsi,%rcx,4), %ecx
leaq (%rdx,%rcx), %r14
addq $0x2, %r14
testb $0x1, 0x11(%rax)
jne 0x7016
addq %rcx, %rdx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
cmpw $0x0, 0x2(%rdx)
leaq 0x2(%rdx), %rdx
jne 0x6f6f
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7c66
movq (%r15), %r14
movq 0x8(%r15), %r15
movl $0x20, %edi
callq 0x31f0
xorl %ecx, %ecx
movl %ecx, 0x8(%rax)
movq $0x10ffff, 0x10(%rax)   # imm = 0x10FFFF
movl %ecx, 0x18(%rax)
leaq 0x7bcf(%rip), %rdx      # 0xeb80
movq %rdx, (%rax)
leaq -0x88(%rbp), %rdx
movq %rax, -0x18(%rdx)
movq %rdx, -0x10(%rdx)
movq %rcx, -0x8(%rdx)
movb $0x0, (%rdx)
leaq -0x68(%rbp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movw %cx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movw %cx, 0x20(%rax)
leaq (%r14,%r15,2), %rcx
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x77ec
leaq -0xa0(%rbp), %rdi
callq 0x7786
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x7034
callq 0x31c0
jmp 0x7034
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x30e0
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ede
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x7786
movq -0x40(%rbp), %r14
jmp 0x705f
movq %rax, %rbx
cmpq %r12, %r14
je 0x706c
movq %r14, %rdi
callq 0x31c0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O3/bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: ResourcesParser::parserEntryPool(std::basic_ifstream<char, std::char_traits<char>>&, unsigned int, unsigned int, unsigned int)
ResourcesParser::EntryPool ResourcesParser::parserEntryPool(
			ifstream& resources,
			uint32_t entryCount,
			uint32_t dataStart,
			uint32_t dataSize) {
	EntryPool pool;
	pool.pOffsets = shared_ptr<uint32_t>(
			new uint32_t[entryCount],
			default_delete<uint32_t[]>()
	);

	const uint32_t offsetSize = sizeof(uint32_t) * entryCount;
	resources.read((char*)pool.pOffsets.get(), offsetSize);

	pool.offsetCount = entryCount;
	pool.dataSize = dataSize;

	resources.seekg(dataStart - offsetSize, ios::cur);

	pool.pData = shared_ptr<byte>(
			new byte[pool.dataSize],
			default_delete<byte[]>()
	);
	resources.read((char*)pool.pData.get(), pool.dataSize);
	return pool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, -0x48(%rbp)
movl %ecx, %r13d
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl %ecx, %edi
shlq $0x2, %rdi
callq 0x3030
leaq -0x38(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x817a
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
movq %rsi, (%rbx)
movq %rax, 0x8(%rbx)
leal (,%r13,4), %r15d
movq %r14, %rdi
movq %r15, %rdx
callq 0x3240
movl -0x2c(%rbp), %r12d
movl %r13d, 0x24(%rbx)
movl %r12d, 0x20(%rbx)
movq -0x48(%rbp), %rsi
subl %r15d, %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x3260
movl %r12d, %r15d
movq %r15, %rdi
callq 0x3030
leaq -0x38(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x8258
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
movq %rsi, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %r14, %rdi
movq %r15, %rdx
callq 0x3240
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7149
jmp 0x7149
movq %rax, %r14
movq %rbx, %rdi
callq 0x7618
movq %r14, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O3/bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: ResourcesParser::getEntryFromEntryPool(ResourcesParser::EntryPool, unsigned int)
ResTable_entry* ResourcesParser::getEntryFromEntryPool(EntryPool pool, uint32_t index) {
	if(index >= pool.offsetCount) {
		return nullptr;
	}
	uint32_t offset = *(pool.pOffsets.get() + index);
	if(offset == ResTable_type::NO_ENTRY) {
		return nullptr;
	}
	return ((ResTable_entry*)(pool.pData.get() + offset));
}

// Assembly:
cmpl %edx, 0x24(%rsi)
jbe 0x717d
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rax
movl %edx, %ecx
movl (%rax,%rcx,4), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x7180
addq 0x10(%rsi), %rax
jmp 0x7182
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: ResourcesParser::getPackageResouceForId(unsigned int) const
ResourcesParser::PackageResourcePtr ResourcesParser::getPackageResouceForId(uint32_t id) const {
	uint32_t packageId = (id >> 24);
	auto it = mResourceForId.find(packageId);
	if(it==mResourceForId.end()) {
		return nullptr;
	}
	return it->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x60(%rsi), %rdi
testq %rdi, %rdi
je 0x71d8
shrl $0x18, %edx
addq $0x58, %rsi
movq %rsi, %rcx
xorl %r8d, %r8d
cmpl %edx, 0x20(%rdi)
setb %r8b
cmovaeq %rdi, %rcx
movq 0x10(%rdi,%r8,8), %rdi
testq %rdi, %rdi
jne 0x71b6
cmpq %rsi, %rcx
je 0x71d8
cmpl 0x20(%rcx), %edx
jae 0x71e0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rbp
retq
movq 0x28(%rcx), %rdx
movq %rdx, (%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x8(%rax)
testq %rcx, %rcx
je 0x71de
movq 0x7dd5(%rip), %rdx      # 0xefd0
cmpb $0x0, (%rdx)
je 0x7205
incl 0x8(%rcx)
jmp 0x71de
lock
incl 0x8(%rcx)
jmp 0x71de
nop
// File: /workspace/github_cpp_makefile_star2_O3/bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: ResourcesParser::getResTableTypesForId(unsigned int)
vector<ResourcesParser::ResTableTypePtr> ResourcesParser::getResTableTypesForId(uint32_t id) {
	PackageResourcePtr pPackage = getPackageResouceForId(id);
	if(pPackage == nullptr) {
		return vector<ResTableTypePtr>();
	}
	return pPackage->resTablePtrs[TYPE_ID(id)];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x719c
movq (%r15), %rdi
testq %rdi, %rdi
je 0x725a
addq $0x140, %rdi            # imm = 0x140
shrl $0x10, %r14d
movzbl %r14b, %eax
leaq -0x1c(%rbp), %rsi
movl %eax, (%rsi)
callq 0x533a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7694
jmp 0x7268
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x7276
callq 0x3ddc
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x7295
callq 0x3ddc
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O3/bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: ResourcesParser::getNameForResTableMap[abi:cxx11](ResTable_ref const&) const
string ResourcesParser::getNameForResTableMap(const ResTable_ref& ref) const {
	switch(ref.ident) {
		case ResTable_map::ATTR_TYPE:
			return "ATTR_TYPE";
        case ResTable_map::ATTR_MIN:
			return "ATTR_MIN";
		case ResTable_map::ATTR_MAX:
			return "ATTR_MAX";
		case ResTable_map::ATTR_L10N:
			return "ATTR_L10N";
       	case ResTable_map::ATTR_OTHER:
			return "ATTR_OTHER";
       	case ResTable_map::ATTR_ZERO:
			return "ATTR_ZERO";
       	case ResTable_map::ATTR_ONE:
			return "ATTR_ONE";
       	case ResTable_map::ATTR_TWO:
			return "ATTR_TWO";
       	case ResTable_map::ATTR_FEW:
			return "ATTR_FEW";
       	case ResTable_map::ATTR_MANY:
			return "ATTR_MANY";
		default:
			return getNameForId(ref.ident);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdx), %edx
leal -0x1000000(%rdx), %eax
cmpl $0x9, %eax
ja 0x73a3
leaq 0x3ebd(%rip), %rcx      # 0xb17c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4048(%rip), %rsi      # 0xb31e
leaq 0x404a(%rip), %rdx      # 0xb327
jmp 0x73c2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4054(%rip), %rsi      # 0xb344
leaq 0x4057(%rip), %rdx      # 0xb34e
jmp 0x73c2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x406a(%rip), %rsi      # 0xb374
leaq 0x406c(%rip), %rdx      # 0xb37d
jmp 0x73c2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x400d(%rip), %rsi      # 0xb331
leaq 0x400e(%rip), %rdx      # 0xb339
jmp 0x73c2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3ffc(%rip), %rsi      # 0xb33a
leaq 0x3ffe(%rip), %rdx      # 0xb343
jmp 0x73c2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x400d(%rip), %rsi      # 0xb362
leaq 0x400e(%rip), %rdx      # 0xb36a
jmp 0x73c2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3fbc(%rip), %rsi      # 0xb328
leaq 0x3fbd(%rip), %rdx      # 0xb330
jmp 0x73c2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3fcc(%rip), %rsi      # 0xb34f
leaq 0x3fce(%rip), %rdx      # 0xb358
jmp 0x73c2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3fbf(%rip), %rsi      # 0xb359
leaq 0x3fc0(%rip), %rdx      # 0xb361
jmp 0x73c2
movq %rbx, %rdi
callq 0x5e16
jmp 0x73ca
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3fb0(%rip), %rsi      # 0xb36b
leaq 0x3fb1(%rip), %rdx      # 0xb373
movq %rbx, %rdi
callq 0x3ede
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: ResourcesParser::getValueTypeForResTableMap[abi:cxx11](Res_value const&) const
string ResourcesParser::getValueTypeForResTableMap(const Res_value& value) const {
	switch(value.data) {
		case ResTable_map::TYPE_ANY:
			return "any";
		case ResTable_map::TYPE_REFERENCE:
			return "reference";
		case ResTable_map::TYPE_STRING:
			return "string";
		case ResTable_map::TYPE_INTEGER:
			return "integer";
		case ResTable_map::TYPE_BOOLEAN:
			return "boolean";
		case ResTable_map::TYPE_COLOR:
			return "color";
		case ResTable_map::TYPE_FLOAT:
			return "float";
		case ResTable_map::TYPE_DIMENSION:
			return "dimension";
		case ResTable_map::TYPE_FRACTION:
			return "fraction";
		case ResTable_map::TYPE_ENUM:
			return "enum";
		case ResTable_map::TYPE_FLAGS:
			return "flags";
		default:
			return "unknown";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdx), %eax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
cmpl $0x3f, %eax
jg 0x742b
leal -0x1(%rax), %ecx
cmpl $0x7, %ecx
ja 0x7462
leaq 0x3d95(%rip), %rax      # 0xb1a4
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x3f63(%rip), %rsi      # 0xb382
leaq 0x3f65(%rip), %rdx      # 0xb38b
jmp 0x751d
cmpl $0xfffe, %eax           # imm = 0xFFFE
jle 0x7483
cmpl $0x20000, %eax          # imm = 0x20000
je 0x74ff
cmpl $0x10000, %eax          # imm = 0x10000
je 0x74ef
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x749f
leaq 0x3f28(%rip), %rsi      # 0xb37e
leaq 0x3f24(%rip), %rdx      # 0xb381
jmp 0x751d
cmpl $0x10, %eax
je 0x750f
cmpl $0x20, %eax
jne 0x749f
leaq 0x3f1d(%rip), %rsi      # 0xb394
leaq 0x3f1b(%rip), %rdx      # 0xb399
jmp 0x751d
cmpl $0x40, %eax
je 0x74df
cmpl $0x80, %eax
jne 0x749f
leaq 0x3f0e(%rip), %rsi      # 0xb3a4
leaq 0x3f0f(%rip), %rdx      # 0xb3ac
jmp 0x751d
leaq 0x3f12(%rip), %rsi      # 0xb3b8
leaq 0x3f12(%rip), %rdx      # 0xb3bf
jmp 0x751d
leaq 0x3ed6(%rip), %rsi      # 0xb38c
leaq 0x3ed6(%rip), %rdx      # 0xb393
jmp 0x751d
leaq 0x3c44(%rip), %rsi      # 0xb10a
leaq 0x3c43(%rip), %rdx      # 0xb110
jmp 0x751d
leaq 0x3c47(%rip), %rsi      # 0xb11d
leaq 0x3c47(%rip), %rdx      # 0xb124
jmp 0x751d
leaq 0x3eb4(%rip), %rsi      # 0xb39a
leaq 0x3eb6(%rip), %rdx      # 0xb3a3
jmp 0x751d
leaq 0x3eb7(%rip), %rsi      # 0xb3ad
leaq 0x3eb4(%rip), %rdx      # 0xb3b1
jmp 0x751d
leaq 0x3eac(%rip), %rsi      # 0xb3b2
leaq 0x3eaa(%rip), %rdx      # 0xb3b7
jmp 0x751d
leaq 0x3c01(%rip), %rsi      # 0xb117
leaq 0x3bff(%rip), %rdx      # 0xb11c
movq %rbx, %rdi
callq 0x3ede
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gtonkinhill[P]pairsnp-cpp/src/main.cpp
// Function: show_help(int)
void show_help(int retcode)
{
  FILE* out = (retcode == EXIT_SUCCESS ? stdout : stderr);
  fprintf(out, "SYNOPSIS\n  Fast pairwise SNP distance matrices\n");
  fprintf(out, "USAGE\n  %s [options] alignment.fasta[.gz] > matrix.csv\n", EXENAME);
  fprintf(out, "OPTIONS\n");
  fprintf(out, "  -h\tShow this help\n");
  fprintf(out, "  -v\tPrint version and exit\n");
  fprintf(out, "  -s\tOutput in sparse matrix form (i,j,distance).\n");
  fprintf(out, "  -d\tDistance threshold for sparse output. Only distances <= d will be returned.\n");
  fprintf(out, "  -k\tWill on return the k nearest neighbours for each sample in sparse output.\n");
  fprintf(out, "  -c\tOutput CSV instead of TSV\n");
  fprintf(out, "  -i\tOutput sequence index inplace of header (useful for downstream processing)\n");
  fprintf(out, "  -t\tNumber of threads to use (default=1)\n");
  exit(retcode);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
jne 0x248f
movq 0x5b13(%rip), %rax      # 0x7fa0
jmp 0x2496
movq 0x5b32(%rip), %rax      # 0x7fc8
movq (%rax), %r14
leaq 0x2c64(%rip), %rdi      # 0x5104
movl $0x2f, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22b0
leaq 0x2c7b(%rip), %rsi      # 0x5134
leaq 0x2cac(%rip), %rdx      # 0x516c
movq %r14, %rdi
xorl %eax, %eax
callq 0x21d0
leaq 0x2ca3(%rip), %rdi      # 0x5174
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22b0
leaq 0x2c93(%rip), %rdi      # 0x517d
movl $0x14, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22b0
leaq 0x2c8f(%rip), %rdi      # 0x5192
movl $0x1c, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22b0
leaq 0x2c93(%rip), %rdi      # 0x51af
movl $0x32, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22b0
leaq 0x2cad(%rip), %rdi      # 0x51e2
movl $0x51, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22b0
leaq 0x2ce6(%rip), %rdi      # 0x5234
movl $0x4f, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22b0
leaq 0x2d1d(%rip), %rdi      # 0x5284
movl $0x1f, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22b0
leaq 0x2d24(%rip), %rdi      # 0x52a4
movl $0x50, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22b0
leaq 0x2d5c(%rip), %rdi      # 0x52f5
movl $0x2a, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22b0
movl %ebx, %edi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/gtonkinhill[P]pairsnp-cpp/libs/boost/dynamic_bitset/dynamic_bitset.hpp
// Function: boost::dynamic_bitset<unsigned long, std::allocator<unsigned long>>::operator|=(boost::dynamic_bitset<unsigned long, std::allocator<unsigned long>> const&)
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::operator|=(const dynamic_bitset& rhs)
{
    assert(size() == rhs.size());
    for (size_type i = 0; i < num_blocks(); ++i)
        m_bits[i] |= rhs.m_bits[i];
    //m_zero_unused_bits();
    return *this;
}

// Assembly:
pushq %rax
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
jne 0x3b4d
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x3b48
sarq $0x3, %rcx
movq (%rsi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
orq %r8, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x3b38
movq %rdi, %rax
popq %rcx
retq
leaq 0x1b2f(%rip), %rdi      # 0x5683
leaq 0x18fa(%rip), %rsi      # 0x5455
leaq 0x1cb9(%rip), %rcx      # 0x581b
movl $0x369, %edx            # imm = 0x369
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/gtonkinhill[P]pairsnp-cpp/libs/boost/dynamic_bitset/dynamic_bitset.hpp
// Function: boost::dynamic_bitset<unsigned long, std::allocator<unsigned long>>::operator&=(boost::dynamic_bitset<unsigned long, std::allocator<unsigned long>> const&)
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::operator&=(const dynamic_bitset& rhs)
{
    assert(size() == rhs.size());
    for (size_type i = 0; i < num_blocks(); ++i)
        m_bits[i] &= rhs.m_bits[i];
    return *this;
}

// Assembly:
pushq %rax
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
jne 0x46eb
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x46e6
sarq $0x3, %rcx
movq (%rsi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
andq %r8, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x46d6
movq %rdi, %rax
popq %rcx
retq
leaq 0xf91(%rip), %rdi       # 0x5683
leaq 0xd5c(%rip), %rsi       # 0x5455
leaq 0xf98(%rip), %rcx       # 0x5698
movl $0x35f, %edx            # imm = 0x35F
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/johan-bjareholt[P]lua-compiler/src/main.cc
// Function: parse_flags(int, char**)
void parse_flags(int argc, char** argv){
	for (int i=1; i<argc; i++){
        if (argv[i][0] == '-'){
            switch (argv[i][1]){
                case 'o':
                    i++;
                    output_mode = OUTPUT_FILE;
                    output_filename = argv[i];
                    break;
                case 'd':
                    debug_lex = true;
                    debug_grammar = true;
                    debug_cfg = true;
                    break;
                default:
                    std::cout << "Unknown option -"<< argv[i][1] << std::endl;
                    exit(1);
                    break;
            } 
        }
        else
		    set_input_file(argv[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x4b10
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %r15d
movslq %r15d, %r12
movq (%rbx,%r12,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x4aed
movzbl 0x1(%rdi), %eax
cmpl $0x64, %eax
je 0x4af4
cmpl $0x6f, %eax
jne 0x4b1f
leal 0x1(%r12), %r15d
movl $0x1, 0x18840(%rip)     # 0x1d300
movq 0x8(%rbx,%r12,8), %r12
movq 0x18844(%rip), %r13     # 0x1d310
movq %r12, %rdi
callq 0x3100
leaq 0x1882d(%rip), %rdi     # 0x1d308
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x33f0
jmp 0x4b08
callq 0x142fc
jmp 0x4b08
movb $0x1, %al
movb %al, 0x187dc(%rip)      # 0x1d2d8
movb %al, 0x187d7(%rip)      # 0x1d2d9
movb %al, 0x187d2(%rip)      # 0x1d2da
incl %r15d
cmpl %r14d, %r15d
jl 0x4a97
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x184aa(%rip), %rdi     # 0x1cfd0
leaq 0x10508(%rip), %rsi     # 0x15035
callq 0x3250
movq (%rbx,%r12,8), %rcx
movsbl 0x1(%rcx), %esi
movq %rax, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x3110
movl $0x1, %edi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O3/johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: BBlock::dump(std::ostream&)
void BBlock::dump(std::ostream& ss)
{
    ss << "BBlock " << " @ " << this << endl;
    for(auto i : instructions)
        i.dump(ss);
    ss << "True: " << trueExit << endl;
    ss << "False: " << falseExit << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10256(%rip), %rsi     # 0x150c2
movl $0x7, %edx
movq %rbx, %rdi
callq 0x32b0
leaq 0x1024a(%rip), %rsi     # 0x150ca
movl $0x3, %edx
movq %rbx, %rdi
callq 0x32b0
movq %rbx, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
movq (%r14), %r13
movq %r14, %rbx
cmpq %r14, %r13
je 0x4f85
leaq -0x58(%rbp), %r15
leaq -0x38(%rbp), %r14
movb 0x10(%r13), %al
movb %al, -0x90(%rbp)
leaq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movq 0x18(%r13), %rsi
movq 0x20(%r13), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x4baa
movq %r15, -0x68(%rbp)
movq 0x38(%r13), %rsi
movq 0x40(%r13), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x4baa
movq %r14, -0x48(%rbp)
movq 0x58(%r13), %rsi
movq 0x60(%r13), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x4baa
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
callq 0x4d56
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x4f55
callq 0x3230
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x4f63
callq 0x3230
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x4f78
callq 0x3230
movq (%r13), %r13
cmpq %rbx, %r13
jne 0x4edc
leaq 0x10142(%rip), %rsi     # 0x150ce
movl $0x6, %edx
movq %r12, %rdi
callq 0x32b0
movq 0x18(%rbx), %rsi
movq %r12, %rdi
callq 0x31d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
leaq 0x100ff(%rip), %rsi     # 0x150d5
movl $0x7, %edx
movq %r12, %rdi
callq 0x32b0
movq 0x20(%rbx), %rsi
movq %r12, %rdi
callq 0x31d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x503e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x503e
callq 0x3230
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x5064
callq 0x3230
jmp 0x5064
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x7d26
movq %rbx, %rdi
callq 0x3470
// File: /workspace/github_cpp_makefile_star2_O3/johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: dumpDot(std::ostream&, std::__cxx11::list<BBlock*, std::allocator<BBlock*>>)
void dumpDot(std::ostream& ss, std::list<BBlock*> startblocks){
    traversed_blocks = std::set<BBlock*>();
    ss << "digraph {" << std::endl;
    ss << "size=\"6,6\";" << std::endl;
    ss << "node [color=lightblue, style=filled];" << std::endl;

    for (BBlock* block : startblocks){
        block->dumpDot(ss);
    }
    
    ss << "}" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
leaq 0x182bc(%rip), %rdi     # 0x1d360
callq 0x7fc0
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x50f5
movl -0x48(%rbp), %ecx
movl %ecx, 0x182ad(%rip)     # 0x1d368
leaq 0x182a6(%rip), %rcx     # 0x1d368
movq %rax, 0x182a7(%rip)     # 0x1d370
movups -0x38(%rbp), %xmm0
movups %xmm0, 0x182a4(%rip)    # 0x1d378
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, 0x182a5(%rip)     # 0x1d388
xorl %eax, %eax
movq %rax, -0x40(%rbp)
movq %r15, -0x38(%rbp)
movq %r15, -0x30(%rbp)
movq %rax, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7f68
leaq 0xffd8(%rip), %rsi      # 0x150dd
movl $0x9, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
leaq 0xffa7(%rip), %rsi      # 0x150e7
movl $0xb, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
leaq 0xff78(%rip), %rsi      # 0x150f3
movl $0x25, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
movq (%r14), %r15
cmpq %r14, %r15
je 0x51c8
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x520e
movq (%r15), %r15
jmp 0x51b2
leaq 0x102dd(%rip), %rsi     # 0x154ac
movl $0x1, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: Expression::dump(std::ostream&, int)
void Expression::dump(std::ostream& ss, int depth)
{
    for(int i=0; i<depth; i++)  
        ss << "  ";
    switch(kind)
    {
        case 'N':  ss << op    << endl; break;
        case 'V':  ss << name  << endl; break;
        case 'C':  ss << value << endl; break;
	    case 'S':  ss << name  << endl; break;
	    case 'f':  ss << name  << endl; break;
        default: std::cout << "ERROR: bad expression kind '" << kind << '\''<< endl; ss << "bad expression" << endl; break;
    }
    if(left!=NULL)
        left->dump(ss, depth+1);
    if(right!=NULL)
        right->dump(ss, depth+1);
    for (Expression* exp : subexp)
        exp->dump(ss, depth+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
jle 0x57a9
leaq 0xfb9e(%rip), %r12      # 0x1532f
movl %ebx, %r13d
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x32b0
decl %r13d
jne 0x5794
movzbl 0x28(%r15), %eax
cmpl $0x52, %eax
jle 0x57d0
cmpl $0x53, %eax
je 0x57c6
cmpl $0x56, %eax
je 0x57c6
cmpl $0x66, %eax
jne 0x5891
movq 0x30(%r15), %rsi
movq 0x38(%r15), %rdx
jmp 0x57f1
cmpl $0x43, %eax
je 0x5880
cmpl $0x4e, %eax
jne 0x5891
movb 0x29(%r15), %al
leaq -0x29(%rbp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x32b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
movq (%r15), %rdi
testq %rdi, %rdi
je 0x5836
leal 0x1(%rbx), %edx
movq %r14, %rsi
callq 0x5770
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x584a
leal 0x1(%rbx), %edx
movq %r14, %rsi
callq 0x5770
movq 0x10(%r15), %r12
addq $0x10, %r15
cmpq %r15, %r12
je 0x5871
incl %ebx
movq 0x10(%r12), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5770
movq (%r12), %r12
cmpq %r15, %r12
jne 0x5859
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x2c(%r15), %esi
movq %r14, %rdi
callq 0x3450
jmp 0x57f9
movq 0x17738(%rip), %r12     # 0x1cfd0
leaq 0xf893(%rip), %rsi      # 0x15132
movl $0x1c, %edx
movq %r12, %rdi
callq 0x32b0
movb 0x28(%r15), %al
leaq -0x2a(%rbp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x32b0
leaq -0x2b(%rbp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
leaq 0xf847(%rip), %rsi      # 0x1514f
movl $0xe, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
jmp 0x5816
// File: /workspace/github_cpp_makefile_star2_O3/johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: FunctionCall(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::list<Expression*, std::allocator<Expression*>>)
Expression *FunctionCall(std::string name, std::list<Expression*> args){
    Expression *result = new Expression('f',NULL,NULL);
    result->name = name;
    result->op = 'f';
    result->subexp = args;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movl $0x50, %edi
callq 0x3260
movq %rax, %r14
leaq 0x10(%rax), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r15, 0x18(%rax)
movq %r15, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r14)
movb $0x66, %r13b
movb %r13b, 0x28(%r14)
leaq 0x30(%r14), %rdi
leaq 0x40(%r14), %rcx
movq %rcx, 0x30(%r14)
movq %rax, 0x38(%r14)
movb $0x0, 0x40(%r14)
movq %r12, %rsi
callq 0x3150
movb %r13b, 0x29(%r14)
cmpq %rbx, %r15
je 0x5b4a
movq (%rbx), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x8220
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: Statement::dump(std::ostream&, int)
void Statement::dump(std::ostream& ss, int indent)
{
    for(int i=0; i<indent; i++)
        ss << "  ";
    ss << "Statement(" << kind << ")" << endl ;
    for( auto e: expressions ){
        e->dump(ss, indent+1);
    }
    for( auto c: children )
        c->dump(ss, indent+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
testl %edx, %edx
jle 0x5bfb
leaq 0xf74c(%rip), %r12      # 0x1532f
movl %ebx, %r15d
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x32b0
decl %r15d
jne 0x5be6
leaq 0xf55c(%rip), %rsi      # 0x1515e
movl $0xa, %edx
movq %r14, %rdi
callq 0x32b0
movq -0x38(%rbp), %r15
movb 0x30(%r15), %al
leaq -0x29(%rbp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x32b0
movq %rax, %r12
leaq 0x1113b(%rip), %rsi     # 0x16d6f
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3180
movq (%r15), %r13
movq 0x8(%r15), %r15
cmpq %r15, %r13
je 0x5c91
leal 0x1(%rbx), %r12d
movq (%r13), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x5770
addq $0x8, %r13
cmpq %r15, %r13
jne 0x5c79
movq -0x38(%rbp), %rax
movq 0x18(%rax), %r12
movq 0x20(%rax), %r15
cmpq %r15, %r12
je 0x5cbb
incl %ebx
movq (%r12), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5bbe
addq $0x8, %r12
cmpq %r15, %r12
jne 0x5ca4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: Assign(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Expression*)
Statement *Assign(string target, Expression *val)
{
    Statement *result = new Statement('A');
    result->expressions.push_back( Variable(target) );
    result->expressions.push_back(val);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, -0x28(%rbp)
movl $0x38, %edi
callq 0x3260
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movb $0x41, 0x30(%rax)
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x4baa
movq %r15, %rdi
callq 0x59da
leaq -0x50(%rbp), %rdx
movq %rax, (%rdx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x83e0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x5d48
callq 0x3230
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5d5c
movq %r14, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x5d68
leaq -0x28(%rbp), %rdx
movq %rbx, %rdi
callq 0x851a
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x5d89
callq 0x3230
movq %rbx, %rdi
callq 0x3470