LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/apps/mshcompare/mshcompare.cpp
// Function: WriteProperties(gaps::R3MeshPropertySet*, char*)
static int
WriteProperties(R3MeshPropertySet *properties, char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Write properties
  if (!properties->Write(filename)) exit(-1);

  // Print statistics
  if (print_verbose) {
    printf("Wrote properties to %s\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Vertices = %d\n", properties->Mesh()->NVertices());
    printf("  # Properties = %d\n", properties->NProperties());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xa6110
leaq 0x8(%rsp), %rdi
callq 0x122e0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1ba10
cmpl $0x0, %eax
jne 0x12250
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd500
cmpl $0x0, 0xc0989(%rip)     # 0xd2be0
je 0x122cf
movq 0x18(%rsp), %rsi
leaq 0x98fc9(%rip), %rdi     # 0xab22e
movb $0x0, %al
callq 0xd070
leaq 0x8(%rsp), %rdi
callq 0xa61d0
leaq 0x98e1e(%rip), %rdi     # 0xab09b
movb $0x1, %al
callq 0xd070
movq 0x20(%rsp), %rdi
callq 0x12920
movq %rax, %rdi
callq 0x12340
movl %eax, %esi
leaq 0x98e33(%rip), %rdi     # 0xab0d2
movb $0x0, %al
callq 0xd070
movq 0x20(%rsp), %rdi
callq 0x126c0
movl %eax, %esi
leaq 0x98f60(%rip), %rdi     # 0xab219
movb $0x0, %al
callq 0xd070
movq 0xbfcd9(%rip), %rax     # 0xd1fa0
movq (%rax), %rdi
callq 0xd4d0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/useBlob2.cc
// Function: main
int main(int argc, char const *argv[])
{
	string str;
	StrBlob blob;
	ifstream data("./data/storyDataFile");

	while (getline(data, str))
		blob.push_back(str);

	for (StrBlobPtr it= blob.begin(); neq(it, blob.end()); it.incr())
		cout << it.deref() << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2190
leaq -0x40(%rbp), %rdi
callq 0x25a0
jmp 0x239d
leaq 0x2c60(%rip), %rsi      # 0x5004
leaq -0x258(%rbp), %rdi
movl $0x8, %edx
callq 0x2220
jmp 0x23b7
jmp 0x23b9
leaq -0x258(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2030
movq %rax, -0x290(%rbp)
jmp 0x23d2
movq -0x290(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2170
movb %al, -0x291(%rbp)
jmp 0x23f0
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x23fc
jmp 0x2440
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x25c0
jmp 0x240b
jmp 0x23b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x257f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2576
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x256a
leaq -0x270(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x25f0
jmp 0x2452
jmp 0x2454
leaq -0x288(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2650
jmp 0x2466
leaq -0x270(%rbp), %rdi
leaq -0x288(%rbp), %rsi
callq 0x2620
movb %al, -0x292(%rbp)
jmp 0x2481
leaq -0x288(%rbp), %rdi
callq 0x26c0
movb -0x292(%rbp), %al
testb $0x1, %al
jne 0x24d0
leaq -0x270(%rbp), %rdi
callq 0x26c0
jmp 0x2539
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x252b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x288(%rbp), %rdi
callq 0x26c0
jmp 0x252b
leaq -0x270(%rbp), %rdi
callq 0x26e0
movq %rax, -0x2a0(%rbp)
jmp 0x24e5
movq -0x2a0(%rbp), %rsi
movq 0x5acd(%rip), %rdi      # 0x7fc0
callq 0x2120
movq %rax, -0x2a8(%rbp)
jmp 0x2501
movq -0x2a8(%rbp), %rdi
movq 0x5a91(%rip), %rsi      # 0x7fa0
callq 0x2150
jmp 0x2516
jmp 0x2518
leaq -0x270(%rbp), %rdi
callq 0x27b0
jmp 0x2526
jmp 0x2454
leaq -0x270(%rbp), %rdi
callq 0x26c0
jmp 0x256a
movl $0x0, -0x4(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x2040
leaq -0x40(%rbp), %rdi
callq 0x2870
leaq -0x30(%rbp), %rdi
callq 0x20e0
movl -0x4(%rbp), %eax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
leaq -0x258(%rbp), %rdi
callq 0x2040
leaq -0x40(%rbp), %rdi
callq 0x2870
leaq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x48(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq %rax, %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0xa0(%rsp)
movq %rdi, 0x98(%rsp)
callq 0x1620
movq 0x20(%rsp), %rdi
movl %eax, 0x94(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1640
movq 0x28(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x90(%rsp)
movb $0x0, 0x8f(%rsp)
callq 0x1660
leaq 0x70(%rsp), %rdi
callq 0x1660
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
cmpl 0x94(%rsp), %eax
jge 0x13b8
movq 0x20(%rsp), %rdi
movslq 0x6c(%rsp), %rsi
callq 0x1640
movl (%rax), %eax
cmpl 0x90(%rsp), %eax
jge 0x136a
movq 0x20(%rsp), %rdi
movslq 0x6c(%rsp), %rsi
callq 0x1640
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x1670
jmp 0x1341
jmp 0x13a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1840
movq 0x28(%rsp), %rdi
callq 0x1840
jmp 0x146a
movq 0x20(%rsp), %rdi
movslq 0x6c(%rsp), %rsi
callq 0x1640
movl (%rax), %eax
cmpl 0x90(%rsp), %eax
jle 0x13a4
movq 0x20(%rsp), %rdi
movslq 0x6c(%rsp), %rsi
callq 0x1640
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq 0x1670
jmp 0x13a2
jmp 0x13a4
jmp 0x13a6
jmp 0x13a8
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x12f8
movq 0x28(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1670
jmp 0x13cc
movq 0x28(%rsp), %rdi
callq 0x17a0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x17d0
leaq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1810
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0x17a0
movq 0x28(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x16e0
movq %rax, 0x10(%rsp)
jmp 0x142d
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x1, 0x8f(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1840
testb $0x1, 0x8f(%rsp)
jne 0x145d
movq 0x28(%rsp), %rdi
callq 0x1840
movq 0x18(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movl $0x0, 0x74(%rsp)
movq 0x5b4d(%rip), %rdi      # 0x6fe0
leaq 0x70(%rsp), %rsi
callq 0x1070
leaq 0x50(%rsp), %rdi
callq 0x1660
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x70(%rsp), %eax
jge 0x14ff
movq 0x5b20(%rip), %rdi      # 0x6fe0
leaq 0x6c(%rsp), %rsi
callq 0x1070
jmp 0x14cc
leaq 0x50(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
callq 0x1670
jmp 0x14dd
jmp 0x14df
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x14af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x1606
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x18a0
jmp 0x1510
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1280
jmp 0x1521
leaq 0x8(%rsp), %rdi
callq 0x1840
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x70(%rsp), %eax
jge 0x15e1
movslq 0x4(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x1640
movl (%rax), %esi
movq 0x5a77(%rip), %rdi      # 0x6fd0
callq 0x1120
jmp 0x1560
movl 0x4(%rsp), %eax
addl $0x1, %eax
cmpl 0x70(%rsp), %eax
jge 0x15b8
movq 0x5a5c(%rip), %rdi      # 0x6fd0
leaq 0x2a89(%rip), %rsi      # 0x4004
callq 0x10a0
jmp 0x1582
jmp 0x15cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x1840
jmp 0x1606
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1840
jmp 0x1606
movq 0x5a11(%rip), %rdi      # 0x6fd0
movq 0x59fa(%rip), %rsi      # 0x6fc0
callq 0x10d0
jmp 0x15cd
jmp 0x15cf
jmp 0x15d1
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1533
movl $0x0, 0x74(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1840
leaq 0x50(%rsp), %rdi
callq 0x1840
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0x1840
movq 0x40(%rsp), %rdi
callq 0x1130
nopw (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2140
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movl $0x38, %edx
callq 0x2190
leaq -0xb0(%rbp), %rdi
movl $0x50, %esi
leaq 0xad2e(%rip), %rdx      # 0x1235e
leaq -0x58(%rbp), %rcx
callq 0x2180
movq -0x8(%rbp), %rdi
leaq 0xad26(%rip), %rsi      # 0x1236a
callq 0x21c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2350
movq -0x8(%rbp), %rdi
leaq 0xad15(%rip), %rsi      # 0x1237a
callq 0x2350
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2350
movq -0x8(%rbp), %rdi
leaq 0xacf2(%rip), %rsi      # 0x12378
callq 0x2350
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2350
movq -0x8(%rbp), %rdi
leaq 0xacd1(%rip), %rsi      # 0x12378
callq 0x2350
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x2350
movq -0x8(%rbp), %rdi
leaq 0xacb0(%rip), %rsi      # 0x12378
callq 0x2350
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x2350
cmpl $0x0, -0x14(%rbp)
jne 0x76f5
movq -0x8(%rbp), %rdi
leaq 0xac8e(%rip), %rsi      # 0x1237c
callq 0x2350
jmp 0x7739
cmpl $0x1, -0x14(%rbp)
jne 0x770d
movq -0x8(%rbp), %rdi
leaq 0xac7f(%rip), %rsi      # 0x12385
callq 0x2350
jmp 0x7737
cmpl $0x2, -0x14(%rbp)
jne 0x7725
movq -0x8(%rbp), %rdi
leaq 0xac72(%rip), %rsi      # 0x12390
callq 0x2350
jmp 0x7735
movq -0x8(%rbp), %rdi
leaq 0xac6b(%rip), %rsi      # 0x1239b
callq 0x2350
jmp 0x7737
jmp 0x7739
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bluesky466[P]ResourcesParser/main.cpp
// Function: getArgv(char const*, char**, int)
const char* getArgv(const char* argv, char *argvs[], int count) {
	int index = findArgvIndex(argv, argvs, count);
	if(index>=0 && index+1 < count) {
		return argvs[index+1];
	}
	return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x4160
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x414e
movl -0x20(%rbp), %eax
addl $0x1, %eax
cmpl -0x1c(%rbp), %eax
jge 0x414e
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x4156
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: bluesky466[P]ResourcesParser/main.cpp
// Function: findArgvIndex(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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x41b1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3390
cmpl $0x0, %eax
jne 0x41a4
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x41b8
jmp 0x41a6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x417a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq 0x22ded(%rip), %rdi     # 0x26fc8
leaq 0x15e31(%rip), %rsi     # 0x1a013
callq 0x3260
movq %rax, %rdi
movq 0x22db7(%rip), %rsi     # 0x26fa8
callq 0x3290
movq %rax, %rdi
movq 0x22da8(%rip), %rsi     # 0x26fa8
callq 0x3290
movq 0x22dbc(%rip), %rdi     # 0x26fc8
leaq 0x15e22(%rip), %rsi     # 0x1a035
callq 0x3260
movq %rax, %rdi
movq 0x22d86(%rip), %rsi     # 0x26fa8
callq 0x3290
movq 0x22d9a(%rip), %rdi     # 0x26fc8
leaq 0x15e20(%rip), %rsi     # 0x1a055
callq 0x3260
movq %rax, %rdi
movq 0x22d64(%rip), %rsi     # 0x26fa8
callq 0x3290
movq 0x22d78(%rip), %rdi     # 0x26fc8
leaq 0x15e1e(%rip), %rsi     # 0x1a075
callq 0x3260
movq %rax, %rdi
movq 0x22d42(%rip), %rsi     # 0x26fa8
callq 0x3290
movq 0x22d56(%rip), %rdi     # 0x26fc8
leaq 0x15e2b(%rip), %rsi     # 0x1a0a4
callq 0x3260
movq %rax, %rdi
movq 0x22d20(%rip), %rsi     # 0x26fa8
callq 0x3290
popq %rbp
retq
nop
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $0x0, -0x25(%rbp)
callq 0xc230
movl -0x1c(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x3030
movq %rax, -0x70(%rbp)
jmp 0xac2a
movq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xbd10
jmp 0xac39
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq %rsi, -0x90(%rbp)
callq 0xbd40
movq -0x90(%rbp), %rdi
callq 0xbd70
movq -0x80(%rbp), %rdi
movl -0x1c(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0xbd90
movq -0x88(%rbp), %rdi
movq %rax, %rsi
movl -0x4c(%rbp), %eax
movl %eax, %edx
callq 0x32f0
jmp 0xac8c
movq -0x80(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x24(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %eax
movl -0x4c(%rbp), %ecx
subl %ecx, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x3350
jmp 0xacb6
movq -0x80(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x98(%rbp)
jmp 0xaccd
movq -0x98(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0xbdb0
jmp 0xacdf
movq -0x80(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x60(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0xbde0
movq -0xb0(%rbp), %rdi
callq 0xbe10
movq -0xa8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0xbe30
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
movq -0x80(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, %edx
callq 0x32f0
jmp 0xad3b
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0xad67
jmp 0xad5e
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xc000
jmp 0xad74
movq -0x80(%rbp), %rdi
callq 0xc000
movq -0x78(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x24(%rsi), %eax
jb 0xada9
movq $0x0, -0x8(%rbp)
jmp 0xade2
movq -0x28(%rbp), %rdi
callq 0xbd90
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0xadcb
movq $0x0, -0x8(%rbp)
jmp 0xade2
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0xbe30
movl -0x20(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %eax
shrl $0x18, %eax
movl %eax, -0x18(%rbp)
addq $0x50, %rdi
leaq -0x18(%rbp), %rsi
callq 0xc260
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x50, %rdi
callq 0xc2c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc290
testb $0x1, %al
jne 0xae94
jmp 0xaea3
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbef0
jmp 0xaebc
leaq -0x20(%rbp), %rdi
callq 0xc2f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x6650
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0xae30
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb930
testb $0x1, %al
jne 0xaf11
jmp 0xaf33
movq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3150
movq -0x50(%rbp), %rdi
callq 0x7db0
movl $0x1, -0x2c(%rbp)
jmp 0xaf8b
leaq -0x28(%rbp), %rdi
callq 0x6550
movq %rax, %rdi
addq $0x140, %rdi            # imm = 0x140
movzbl -0x12(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x66b0
movq %rax, -0x58(%rbp)
jmp 0xaf5c
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0xc310
jmp 0xaf6b
movl $0x1, -0x2c(%rbp)
jmp 0xaf8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4820
jmp 0xaf9e
leaq -0x28(%rbp), %rdi
callq 0x4820
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: ResourcesParser::isTableMapForAttrDesc(ResTable_ref const&)
bool ResourcesParser::isTableMapForAttrDesc(const ResTable_ref& ref) {
	switch(ref.ident) {
		case ResTable_map::ATTR_TYPE:
        case ResTable_map::ATTR_MIN:
		case ResTable_map::ATTR_MAX:
		case ResTable_map::ATTR_L10N:
       	case ResTable_map::ATTR_OTHER:
       	case ResTable_map::ATTR_ZERO:
       	case ResTable_map::ATTR_ONE:
       	case ResTable_map::ATTR_TWO:
       	case ResTable_map::ATTR_FEW:
       	case ResTable_map::ATTR_MANY:
			return true;
		default:
			return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0xff000000, %eax       # imm = 0xFF000000
subl $0x9, %eax
ja 0xb360
jmp 0xb35a
movb $0x1, -0x1(%rbp)
jmp 0xb364
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x24e1
movq 0xeac0(%rip), %rax      # 0x10f98
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x24ef
movq 0xeae0(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8bb6(%rip), %rsi      # 0xb0b8
movb $0x0, %al
callq 0x2290
movq -0x10(%rbp), %rdi
leaq 0x8bd4(%rip), %rsi      # 0xb0e8
leaq 0x8c05(%rip), %rdx      # 0xb120
movb $0x0, %al
callq 0x2290
movq -0x10(%rbp), %rdi
leaq 0x8bfb(%rip), %rsi      # 0xb128
movb $0x0, %al
callq 0x2290
movq -0x10(%rbp), %rdi
leaq 0x8bf2(%rip), %rsi      # 0xb131
movb $0x0, %al
callq 0x2290
movq -0x10(%rbp), %rdi
leaq 0x8bf5(%rip), %rsi      # 0xb146
movb $0x0, %al
callq 0x2290
movq -0x10(%rbp), %rdi
leaq 0x8c00(%rip), %rsi      # 0xb163
movb $0x0, %al
callq 0x2290
movq -0x10(%rbp), %rdi
leaq 0x8c21(%rip), %rsi      # 0xb196
movb $0x0, %al
callq 0x2290
movq -0x10(%rbp), %rdi
leaq 0x8c61(%rip), %rsi      # 0xb1e8
movb $0x0, %al
callq 0x2290
movq -0x10(%rbp), %rdi
leaq 0x8c9f(%rip), %rsi      # 0xb238
movb $0x0, %al
callq 0x2290
movq -0x10(%rbp), %rdi
leaq 0x8cad(%rip), %rsi      # 0xb258
movb $0x0, %al
callq 0x2290
movq -0x10(%rbp), %rdi
leaq 0x8cec(%rip), %rsi      # 0xb2a9
movb $0x0, %al
callq 0x2290
movl -0x4(%rbp), %edi
callq 0x2250
nopl (%rax)
// File: 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>>&&)
inline dynamic_bitset<Block, Allocator>& dynamic_bitset<Block, Allocator>::
operator=(dynamic_bitset<Block, Allocator>&& b)
{
    if (boost::addressof(b) == this) { return *this; }

    m_bits = boost::move(b.m_bits);
    m_num_bits = boost::move(b.m_num_bits);
    // Required so that assert(m_check_invariants()); works.
    assert((b.m_bits = buffer_type()).empty());
    b.m_num_bits = 0;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8d10
movq -0x38(%rbp), %rcx
cmpq %rcx, %rax
jne 0x4f77
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5019
movq -0x18(%rbp), %rdi
callq 0x8d20
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x8d30
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x8d60
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20d0
leaq -0x30(%rbp), %rdi
callq 0x8d70
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8d30
movq %rax, %rdi
callq 0x8d90
testb $0x1, %al
jne 0x4fdb
jmp 0x4fdd
jmp 0x4ffc
leaq 0x67c1(%rip), %rdi      # 0xb7a5
leaq 0x641e(%rip), %rsi      # 0xb409
movl $0x2e7, %edx            # imm = 0x2E7
leaq 0x67d1(%rip), %rcx      # 0xb7c8
callq 0x2100
leaq -0x30(%rbp), %rdi
callq 0x6650
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, 0x18(%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x74b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x74b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x5068
jmp 0x5087
leaq 0x666e(%rip), %rdi      # 0xb6dd
leaq 0x6393(%rip), %rsi      # 0xb409
movl $0x369, %edx            # imm = 0x369
leaq 0x67f3(%rip), %rcx      # 0xb875
callq 0x2100
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x7490
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x50e5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8cf0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x75e0
movq -0x38(%rbp), %rcx
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x508f
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: gtonkinhill[P]pairsnp-cpp/libs/boost/dynamic_bitset/dynamic_bitset.hpp
// Function: boost::dynamic_bitset<unsigned long, std::allocator<unsigned long>>::init_from_unsigned_long(unsigned long, unsigned long)
void init_from_unsigned_long(size_type num_bits,
                                 unsigned long value/*,
                                 const Allocator& alloc*/)
    {

        assert(m_bits.size() == 0);

        m_bits.resize(calc_num_blocks(num_bits));
        m_num_bits = num_bits;

        typedef unsigned long num_type;
        typedef boost::detail::dynamic_bitset_impl
            ::shifter<num_type, bits_per_block, ulong_width> shifter;

        //if (num_bits == 0)
        //    return;

        // zero out all bits at pos >= num_bits, if any;
        // note that: num_bits == 0 implies value == 0
        if (num_bits < static_cast<size_type>(ulong_width)) {
            const num_type mask = (num_type(1) << num_bits) - 1;
            value &= mask;
        }

        typename buffer_type::iterator it = m_bits.begin();
        for( ; value; shifter::left_shift(value), ++it) {
            *it = static_cast<block_type>(value);
        }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x6720
cmpq $0x0, %rax
jne 0x6599
jmp 0x65b8
leaq 0x4e56(%rip), %rdi      # 0xb3f6
leaq 0x4e62(%rip), %rsi      # 0xb409
movl $0x1d8, %edx            # imm = 0x1D8
leaq 0x4e83(%rip), %rcx      # 0xb436
callq 0x2100
movq -0x10(%rbp), %rdi
callq 0x67d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x6740
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpq $0x40, -0x10(%rbp)
jae 0x6600
movq -0x10(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6800
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6640
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6830
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x18(%rbp), %rdi
callq 0x6850
leaq -0x28(%rbp), %rdi
callq 0x6870
jmp 0x660d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gtonkinhill[P]pairsnp-cpp/libs/boost/dynamic_bitset/dynamic_bitset.hpp
// Function: boost::dynamic_bitset<unsigned long, std::allocator<unsigned long>>::m_check_invariants() const
bool dynamic_bitset<Block, Allocator>::m_check_invariants() const
{
    const block_width_type extra_bits = count_extra_bits();
    if (extra_bits > 0) {
        const block_type mask = detail::dynamic_bitset_impl::max_limit<Block>::value << extra_bits;
        if ((m_highest_block() & mask) != 0)
            return false;
    }
    if (m_bits.size() > m_bits.capacity() || num_blocks() != calc_num_blocks(size()))
        return false;

    return true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x73c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x7354
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq $-0x1, %rax
shlq %cl, %rax
movq %rax, -0x20(%rbp)
callq 0x73f0
movq (%rax), %rax
andq -0x20(%rbp), %rax
cmpq $0x0, %rax
je 0x7352
movb $0x0, -0x1(%rbp)
jmp 0x73aa
jmp 0x7354
movq -0x28(%rbp), %rdi
callq 0x6720
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x7470
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
ja 0x73a0
movq -0x28(%rbp), %rdi
callq 0x7490
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x74b0
movq %rax, %rdi
callq 0x67d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0x73a6
movb $0x0, -0x1(%rbp)
jmp 0x73aa
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x74b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x74b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x8c68
jmp 0x8c87
leaq 0x2a6e(%rip), %rdi      # 0xb6dd
leaq 0x2793(%rip), %rsi      # 0xb409
movl $0x35f, %edx            # imm = 0x35F
leaq 0x2a70(%rip), %rcx      # 0xb6f2
callq 0x2100
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x7490
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x8ce5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8cf0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x75e0
movq -0x38(%rbp), %rcx
andq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8c8f
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x58b9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x5898
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x64, %eax
je 0x583b
jmp 0x5804
movl -0x18(%rbp), %eax
subl $0x6f, %eax
jne 0x5852
jmp 0x580e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x1, 0x38b0f(%rip)     # 0x3e330
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x38b04(%rip), %rdi     # 0x3e338
callq 0x3380
jmp 0x5896
movb $0x1, 0x38ac6(%rip)     # 0x3e308
movb $0x1, 0x38ac0(%rip)     # 0x3e309
movb $0x1, 0x38aba(%rip)     # 0x3e30a
jmp 0x5896
movq 0x3876f(%rip), %rdi     # 0x3dfc8
leaq 0x257d7(%rip), %rsi     # 0x2b037
callq 0x3260
movq %rax, %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %esi
callq 0x3300
movq %rax, %rdi
movq 0x38719(%rip), %rsi     # 0x3dfa0
callq 0x32a0
movl $0x1, %edi
callq 0x3330
jmp 0x58a9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x29660
jmp 0x58ab
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x57c6
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x24a9d(%rip), %rsi     # 0x2b1a6
callq 0x3260
movq %rax, %rdi
leaq 0x24a96(%rip), %rsi     # 0x2b1ae
callq 0x3260
movq -0xa8(%rbp), %rsi
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
movq 0x3786a(%rip), %rsi     # 0x3dfa0
callq 0x32a0
movq -0xa8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9c40
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9c70
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9ca0
testb $0x1, %al
jne 0x6773
jmp 0x67db
leaq -0x20(%rbp), %rdi
callq 0x9cd0
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x9d00
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6600
jmp 0x67a4
leaq -0x90(%rbp), %rdi
callq 0x9db0
leaq -0x20(%rbp), %rdi
callq 0x9df0
jmp 0x6760
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x9db0
jmp 0x6848
movq -0x10(%rbp), %rdi
leaq 0x249cc(%rip), %rsi     # 0x2b1b2
callq 0x3260
movq %rax, %rdi
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3200
movq %rax, %rdi
movq 0x37798(%rip), %rsi     # 0x3dfa0
callq 0x32a0
movq -0x10(%rbp), %rdi
leaq 0x249a1(%rip), %rsi     # 0x2b1b9
callq 0x3260
movq %rax, %rdi
movq -0xa8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x3200
movq %rax, %rdi
movq 0x37766(%rip), %rsi     # 0x3dfa0
callq 0x32a0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x3150
leaq -0x40(%rbp), %rdi
callq 0x9e10
leaq 0x37afc(%rip), %rdi     # 0x3e390
leaq -0x40(%rbp), %rsi
callq 0x9e50
leaq -0x40(%rbp), %rdi
callq 0x9e30
movq -0x8(%rbp), %rdi
leaq 0x24910(%rip), %rsi     # 0x2b1c1
callq 0x3260
movq %rax, %rdi
movq 0x376e0(%rip), %rsi     # 0x3dfa0
callq 0x32a0
movq -0x8(%rbp), %rdi
leaq 0x248fb(%rip), %rsi     # 0x2b1cb
callq 0x3260
movq %rax, %rdi
movq 0x376c1(%rip), %rsi     # 0x3dfa0
callq 0x32a0
movq -0x8(%rbp), %rdi
leaq 0x248e8(%rip), %rsi     # 0x2b1d7
callq 0x3260
movq %rax, %rdi
movq 0x376a2(%rip), %rsi     # 0x3dfa0
callq 0x32a0
movq -0x68(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x9e80
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x5f70
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9eb0
testb $0x1, %al
jne 0x6938
jmp 0x6960
leaq -0x50(%rbp), %rdi
callq 0x9ee0
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6990
leaq -0x50(%rbp), %rdi
callq 0x9f10
jmp 0x6925
movq -0x8(%rbp), %rdi
leaq 0x24d2a(%rip), %rsi     # 0x2b695
callq 0x3260
movq %rax, %rdi
movq 0x37626(%rip), %rsi     # 0x3dfa0
callq 0x32a0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x50, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %ecx
movl $0x66, %esi
movq %rcx, %rdx
callq 0x6f80
jmp 0x74cf
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x3040
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rax
movb $0x66, 0x29(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0xa120
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3230
movq -0x20(%rbp), %rdi
callq 0x34b0
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7625
movq -0x10(%rbp), %rdi
leaq 0x23efe(%rip), %rsi     # 0x2b513
callq 0x3260
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7602
movq -0x10(%rbp), %rdi
leaq 0x23c12(%rip), %rsi     # 0x2b242
callq 0x3260
movq %rax, %rdi
movq -0x60(%rbp), %rax
movsbl 0x30(%rax), %esi
callq 0x3300
movq %rax, %rdi
leaq 0x259d1(%rip), %rsi     # 0x2d020
callq 0x3260
movq %rax, %rdi
movq 0x36942(%rip), %rsi     # 0x3dfa0
callq 0x32a0
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa1c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa1f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa220
testb $0x1, %al
jne 0x7698
jmp 0x76c6
leaq -0x28(%rbp), %rdi
callq 0xa260
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x6fe0
leaq -0x28(%rbp), %rdi
callq 0xa280
jmp 0x7685
movq -0x60(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xa2a0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0xa2d0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa300
testb $0x1, %al
jne 0x76ff
jmp 0x772d
leaq -0x48(%rbp), %rdi
callq 0xa340
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x75e0
leaq -0x48(%rbp), %rdi
callq 0xa360
jmp 0x76ec
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x38, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movl $0x41, %esi
callq 0x75a0
jmp 0x7777
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3100
movq -0x70(%rbp), %rdi
callq 0x7320
movq %rax, -0x68(%rbp)
jmp 0x77a7
movq -0x78(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xa380
jmp 0x77be
leaq -0x50(%rbp), %rdi
callq 0x3528
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa3b0
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3230
jmp 0x780d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3528
movq -0x20(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: If(Expression*, Statement*, Statement*)
Statement *If(Expression *condition, Statement *trueSt, Statement *falseSt)
{
    Statement *result = new Statement('I');
    result->expressions.push_back(condition);
    result->children.push_back(trueSt);
    result->children.push_back(falseSt);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x38, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl $0x49, %esi
callq 0x75a0
jmp 0x7854
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0xa3b0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0xa420
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
leaq -0x18(%rbp), %rsi
callq 0xa420
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3230
movq -0x28(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: Seq(std::initializer_list<Statement*>)
Statement *Seq(initializer_list<Statement*> ss)
{
    Statement *result = new Statement('S');
    for(auto s : ss)
        result->children.push_back(s);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x38, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movl $0x53, %esi
callq 0x75a0
jmp 0x78f0
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xa490
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xa4b0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x7965
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq -0x48(%rbp), %rsi
callq 0xa420
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0x791a
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3230
jmp 0x796f
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34b0
nopl (%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: Loop(Statement*, Expression*, Statement*, Statement*)
Statement *Loop(Statement* pre, Expression* check, Statement* body, Statement* post){
    Statement *result = new Statement('L');
    result->children.push_back(pre);
    result->expressions.push_back(check);
    result->children.push_back(body);
    result->children.push_back(post);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x38, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl $0x4c, %esi
callq 0x75a0
jmp 0x79b8
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
leaq -0x8(%rbp), %rsi
callq 0xa420
movq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa3b0
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
leaq -0x18(%rbp), %rsi
callq 0xa420
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
callq 0xa420
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x3230
movq -0x30(%rbp), %rdi
callq 0x34b0
nopl (%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: While(Expression*, Statement*)
Statement *While(Expression* expression, Statement* body){
    Statement* pre = new Statement('S');
    Expression* check = expression;
    Statement* post = new Statement('S');
	return Loop(pre, check, body, post);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x38, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl $0x53, %esi
callq 0x75a0
jmp 0x7e40
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x38, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movl $0x53, %esi
callq 0x75a0
jmp 0x7e70
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x7980
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3230
jmp 0x7ebf
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3230
movq -0x20(%rbp), %rdi
callq 0x34b0
nopl (%rax,%rax)