LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::Inc()
bool Inc()
	{
		if (IncSingle(indexStack[0], balancedStack[0], firstCacheSize))
		{
			CalcData(0);
			return true;
		}
		for (uint_fast32_t i = 1; i < stackSize; i++)
		{
			if (IncSingle(indexStack[i], balancedStack[i], cache_size))
			{
				for (int j = i; j >= 0; j--) CalcData(j);
				return true;
			}
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rsi
addq $0x18, %rsi
movq %rdi, %rdx
addq $0x30, %rdx
movq 0x10(%rdi), %rcx
callq 0x10730
testb $0x1, %al
jne 0x10681
jmp 0x10697
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd370
movb $0x1, -0x1(%rbp)
jmp 0x1071d
movq $0x1, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x10719
movq -0x28(%rbp), %rdi
movq %rdi, %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq %rdi, %rdx
addq $0x30, %rdx
addq -0x18(%rbp), %rdx
movl $0xc, %ecx
callq 0x10730
testb $0x1, %al
jne 0x106de
jmp 0x10709
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x10703
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xd370
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x106e5
movb $0x1, -0x1(%rbp)
jmp 0x1071d
jmp 0x1070b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1069f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::IncSingle(unsigned long&, bool&, unsigned long)
bool IncSingle(uint_fast32_t& index, bool& balanced, uint_fast32_t frame_size)
	{
		uint_fast32_t end = balanced ? cache->bordersBalanced[frame_size + 1] : cache->bordersUnbalanced[frame_size + 1];
		
		if (++index >= end)
		{
			if (balanced)
			{
				if (firstCacheSize == 0) return false;
				index = cache->bordersUnbalanced[frame_size];
				balanced = false;
				return true;
			}
			else
			{
				index = cache->bordersBalanced[frame_size];
				balanced = true;
				return false;
			}
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
je 0x1076e
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x90(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
jmp 0x10785
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x100(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
addq $0x1, %rax
movq %rax, (%rcx)
cmpq -0x30(%rbp), %rax
jb 0x10809
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
je 0x107e2
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x107bb
movb $0x0, -0x1(%rbp)
jmp 0x1080d
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0xf8(%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1080d
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x88(%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x1080d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::GetProgram()
char* GetProgram()
	{
		uint_fast32_t pIndex = 0;

		for (int i = static_cast<int>(stackSize - 1); i >= 0; i--)
		{
			uint_fast32_t idx = indexStack[i];
			uint_fast32_t size = i == 0 ? firstCacheSize : cache_size;
			
			char* part;
			if (balancedStack[i])
				part = cache->programsBalanced.data() + (idx * cache_size);
			else
				part = cache->programsUnbalanced.data() + (idx * cache_size);
			
			memcpy(currentProgram + pIndex, part, size * sizeof(char));
			pIndex += size;
		}
		currentProgram[pIndex] = '\0';
		return currentProgram;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x8(%rax), %rax
subq $0x1, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x10acc
movq -0x38(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x10a36
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x10a41
movl $0xc, %eax
movq %rax, -0x40(%rbp)
jmp 0x10a41
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movslq -0x14(%rbp), %rcx
testb $0x1, 0x30(%rax,%rcx)
je 0x10a76
movq -0x38(%rbp), %rax
movq (%rax), %rdi
addq $0x58, %rdi
callq 0xaa60
imulq $0xc, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x10a92
movq -0x38(%rbp), %rax
movq (%rax), %rdi
addq $0x70, %rdi
callq 0xaa60
imulq $0xc, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
addq $0xe1, %rdi
addq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
shlq $0x0, %rdx
callq 0x3200
movq -0x28(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10a07
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, 0xe1(%rax,%rcx)
addq $0xe1, %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::Serialize(std::ostream&)
void Serialize(std::ostream& output)
	{
		output << stackSize << " " << firstCacheSize << " ";
		for (uint_fast32_t i = 0; i < max_stack_size; i++)
		{
			output << indexStack[i] << " ";
		}
		for (uint_fast32_t i = 0; i < max_stack_size; i++)
		{
			output << balancedStack[i] << " ";
		}
		output << first;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x3060
movq %rax, %rdi
leaq 0x2287(%rip), %rsi      # 0x131c6
callq 0x32a0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3060
movq %rax, %rdi
leaq 0x2268(%rip), %rsi      # 0x131c6
callq 0x32a0
movq $0x0, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jae 0x10fa5
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rsi
callq 0x3060
movq %rax, %rdi
leaq 0x2234(%rip), %rsi      # 0x131c6
callq 0x32a0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10f6b
movq $0x0, -0x20(%rbp)
cmpq $0x3, -0x20(%rbp)
jae 0x10feb
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
movb 0x30(%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x34f0
movq %rax, %rdi
leaq 0x21ee(%rip), %rsi      # 0x131c6
callq 0x32a0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x10fad
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movb 0xe0(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x34f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ksabry[P]bfbrute/src/ModDivisionTable.cpp
// Function: ModDivisionTable::ModDivisionTable()
ModDivisionTable::ModDivisionTable()
{
	for (uint_fast32_t d = 0; d < 256; d++)
	{
		for (uint_fast32_t k = 0; k < 256; k++)
		{
			table[d][k] = -1;
		}
	}

	for (int k = 1; k < 256; k++)
	{
		table[0][k] = 0;
		
		uint8_t mult = k;
		int cnt = 1;
		while (mult)
		{
			table[mult][256 - k] = cnt;
			cnt++;
			mult += k;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
jae 0x1290c
movq $0x0, -0x18(%rbp)
cmpq $0x100, -0x18(%rbp)     # imm = 0x100
jae 0x128fc
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x128ca
jmp 0x128fe
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x128b8
movl $0x1, -0x1c(%rbp)
cmpl $0x100, -0x1c(%rbp)     # imm = 0x100
jge 0x12982
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
movb %al, -0x1d(%rbp)
movl $0x1, -0x24(%rbp)
cmpb $0x0, -0x1d(%rbp)
je 0x12975
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %edx
movzbl -0x1d(%rbp), %ecx
shlq $0xa, %rcx
addq %rcx, %rax
movl $0x100, %ecx            # imm = 0x100
subl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %ecx
movzbl -0x1d(%rbp), %eax
addl %ecx, %eax
movb %al, -0x1d(%rbp)
jmp 0x12938
jmp 0x12977
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12913
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/badgetc.cc
// Function: main
int main()
{
	char ch;    // using a char here invites disaster!

	// the return from cin.get is converted to char 
	// and then compared to an int
	while ((ch = cin.get()) != EOF)
         	cout.put(ch);
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2e0a(%rip), %rdi      # 0x3fe0
callq 0x1060
movb %al, -0x5(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x11f8
movq 0x2de3(%rip), %rdi      # 0x3fd0
movsbl -0x5(%rbp), %esi
callq 0x1030
jmp 0x11cf
movq 0x2dd1(%rip), %rdi      # 0x3fd0
movq 0x2dba(%rip), %rsi      # 0x3fc0
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: tomfunkhouser[P]gaps/apps/sflinfo/sflinfo.cpp
// Function: main
int main(int argc, char **argv)
{
  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Open scene file
  R3SurfelScene *scene = OpenScene(input_scene_name, input_database_name);
  if (!scene) exit(-1);

  // Print info
  if (!PrintInfo(scene)) exit(-1);

  // Close scene file
  if (!CloseScene(scene)) exit(-1);;

  // Delete scene
  delete scene;
  
  // Return success 
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x166b0
cmpl $0x0, %eax
jne 0x16632
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x136b0
movq 0x1ebf8f(%rip), %rdi    # 0x2025c8
movq 0x1ebf90(%rip), %rsi    # 0x2025d0
callq 0x16b60
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1665c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x136b0
movq 0x10(%rsp), %rdi
callq 0x16c50
cmpl $0x0, %eax
jne 0x16675
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x136b0
movq 0x10(%rsp), %rdi
callq 0x1bd10
cmpl $0x0, %eax
jne 0x1668e
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x136b0
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x166a9
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
addq $0x28, %rsp
retq
// File: tomfunkhouser[P]gaps/apps/sflinfo/sflinfo.cpp
// Function: OpenScene(char const*, char const*)
static R3SurfelScene *
OpenScene(const char *input_scene_name, const char *input_database_name)
{
  // Allocate surfel scene
  R3SurfelScene *scene = new R3SurfelScene();
  if (!scene) {
    RNFail("Unable to allocate scene\n");
    return NULL;
  }

  // Open surfel scene files
  if (!scene->OpenFile(input_scene_name, input_database_name, "r", "r")) {
    delete scene;
    return NULL;
  }

  // Return scene
  return scene;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl $0x1f0, %edi            # imm = 0x1F0
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x394e0
jmp 0x16b8e
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x16bd8
leaq 0x1925c7(%rip), %rdi    # 0x1a916e
movb $0x0, %al
callq 0x14b6f0
movq $0x0, 0x40(%rsp)
jmp 0x16c2f
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x1f0, %esi            # imm = 0x1F0
callq 0x13580
jmp 0x16c39
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
leaq 0x19a262(%rip), %r8     # 0x1b0e53
movq %r8, %rcx
callq *0xe8(%rax)
cmpl $0x0, %eax
jne 0x16c25
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x16c1a
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x40(%rsp)
jmp 0x16c2f
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x13960
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/sflinfo/../../pkgs/R3Surfels/R3SurfelTree.h
// Function: gaps::R3SurfelTree::NSurfels(int) const
inline long long R3SurfelTree::
NSurfels(RNBoolean leaves_only) const
{
  // Return number of surfels in tree
  long long n = 0;
  for (int i = 0; i < NNodes(); i++) {
    R3SurfelNode *node = Node(i);
    if (leaves_only && (node->NParts() > 0)) continue;
    for (int j = 0; j < node->NBlocks(); j++) {
      R3SurfelBlock *block = node->Block(j);
      n += block->NSurfels();
    }
  }
  return n;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x1c060
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x1c18d
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x1cf90
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0x1c123
movq 0x20(%rsp), %rdi
callq 0x1cd10
cmpl $0x0, %eax
jle 0x1c123
jmp 0x1c17d
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x1cdc0
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x1c17b
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x1cfc0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1ced0
cltq
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1c12b
jmp 0x1c17d
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1c0d8
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: suyash[P]chan/chan_test.cc
// Function: unbuffered_chan_integers_Test::TestBody()
TEST(unbuffered_chan, integers) {
	chan::unbuffered_chan<int> c;

	std::thread t([&](){
		int x = 0;

		c >> x;
		ASSERT_EQ(1, x);

		c >> x;
		ASSERT_EQ(2, x);

		c >> x;
		ASSERT_EQ(3, x);
	});

	c << 1 << 2 << 3;

	t.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
leaq -0x108(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x4c150
movq -0x138(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0x110(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x46350
jmp 0x46255
leaq -0x100(%rbp), %rdi
movl $0x1, -0x128(%rbp)
leaq -0x128(%rbp), %rsi
callq 0x4c1c0
movq %rax, -0x140(%rbp)
jmp 0x4627b
movq -0x140(%rbp), %rdi
movl $0x2, -0x12c(%rbp)
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x12c(%rbp), %rsi
callq *%rax
movq %rax, -0x148(%rbp)
jmp 0x462a5
movq -0x148(%rbp), %rdi
movl $0x3, -0x130(%rbp)
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x130(%rbp), %rsi
callq *%rax
jmp 0x462c8
leaq -0x110(%rbp), %rdi
callq 0xab70
jmp 0x462d6
leaq -0x110(%rbp), %rdi
callq 0x4c1f0
leaq -0x108(%rbp), %rdi
callq 0x4c220
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
jmp 0x46329
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x4c1f0
leaq -0x108(%rbp), %rdi
callq 0x4c220
movq -0x120(%rbp), %rdi
callq 0xabc0
nopw %cs:(%rax,%rax)
// File: suyash[P]chan/chan_test.cc
// Function: unbuffered_chan_strings_Test::TestBody()
TEST(unbuffered_chan, strings) {
	chan::unbuffered_chan<std::string> c;

	std::thread t([&](){
		std::string x;

		c >> x;
		ASSERT_STREQ("unbuffered", x.c_str());

		c >> x;
		ASSERT_STREQ("chan", x.c_str());

		c >> x;
		ASSERT_STREQ("test", x.c_str());
	});

	c << "unbuffered" << "chan" << "test";

	t.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
leaq -0x128(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x4c280
movq -0x1c8(%rbp), %rax
movq %rax, -0x138(%rbp)
leaq -0x130(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x466c0
jmp 0x46445
leaq -0x120(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x169(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0xabd0
movq -0x1d0(%rbp), %rdx
leaq 0xd3ea(%rip), %rsi      # 0x5385e
leaq -0x168(%rbp), %rdi
callq 0xa950
jmp 0x46482
movq -0x1d8(%rbp), %rdi
leaq -0x168(%rbp), %rsi
callq 0x4c300
movq %rax, -0x1e0(%rbp)
jmp 0x4649e
leaq -0x191(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0xabd0
movq -0x1e8(%rbp), %rdx
leaq 0xd37c(%rip), %rsi      # 0x5383b
leaq -0x190(%rbp), %rdi
callq 0xa950
jmp 0x464cd
movq -0x1e0(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x190(%rbp), %rsi
callq *%rax
movq %rax, -0x1f0(%rbp)
jmp 0x464ed
leaq -0x1b9(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0xabd0
movq -0x1f8(%rbp), %rdx
leaq 0xc179(%rip), %rsi      # 0x52687
leaq -0x1b8(%rbp), %rdi
callq 0xa950
jmp 0x4651c
movq -0x1f0(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x1b8(%rbp), %rsi
callq *%rax
jmp 0x46535
leaq -0x1b8(%rbp), %rdi
callq 0xad58
leaq -0x1b9(%rbp), %rdi
callq 0xa680
leaq -0x190(%rbp), %rdi
callq 0xad58
leaq -0x191(%rbp), %rdi
callq 0xa680
leaq -0x168(%rbp), %rdi
callq 0xad58
leaq -0x169(%rbp), %rdi
callq 0xa680
leaq -0x130(%rbp), %rdi
callq 0xab70
jmp 0x4658b
leaq -0x130(%rbp), %rdi
callq 0x4c1f0
leaq -0x128(%rbp), %rdi
callq 0x4c330
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0x466a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0x46678
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0x4666c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0x46660
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0x46654
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0x46648
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xad58
leaq -0x1b9(%rbp), %rdi
callq 0xa680
leaq -0x190(%rbp), %rdi
callq 0xad58
leaq -0x191(%rbp), %rdi
callq 0xa680
leaq -0x168(%rbp), %rdi
callq 0xad58
leaq -0x169(%rbp), %rdi
callq 0xa680
jmp 0x46698
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x4c1f0
leaq -0x128(%rbp), %rdi
callq 0x4c330
movq -0x140(%rbp), %rdi
callq 0xabc0
nopl (%rax)
// File: suyash[P]chan/chan_test.cc
// Function: buffered_chan_integers_Test::TestBody()
TEST(buffered_chan, integers) {
	chan::buffered_chan<int> c(3);

	std::thread t([&](){
		int x = 0;

		c >> x;
		ASSERT_EQ(1, x);

		c >> x;
		ASSERT_EQ(2, x);

		c >> x;
		ASSERT_EQ(3, x);
	});

	c << 1 << 2 << 3;

	t.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
movl $0x3, %esi
callq 0x4c3c0
movq -0x100(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x468b0
jmp 0x467ba
leaq -0xc8(%rbp), %rdi
movl $0x1, -0xf0(%rbp)
leaq -0xf0(%rbp), %rsi
callq 0x4c1c0
movq %rax, -0x108(%rbp)
jmp 0x467e0
movq -0x108(%rbp), %rdi
movl $0x2, -0xf4(%rbp)
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0xf4(%rbp), %rsi
callq *%rax
movq %rax, -0x110(%rbp)
jmp 0x4680a
movq -0x110(%rbp), %rdi
movl $0x3, -0xf8(%rbp)
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0xf8(%rbp), %rsi
callq *%rax
jmp 0x4682d
leaq -0xd8(%rbp), %rdi
callq 0xab70
jmp 0x4683b
leaq -0xd8(%rbp), %rdi
callq 0x4c1f0
leaq -0xd0(%rbp), %rdi
callq 0x4c490
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x4688e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4c1f0
leaq -0xd0(%rbp), %rdi
callq 0x4c490
movq -0xe8(%rbp), %rdi
callq 0xabc0
nopw %cs:(%rax,%rax)
// File: suyash[P]chan/chan_test.cc
// Function: buffered_chan_strings_Test::TestBody()
TEST(buffered_chan, strings) {
	chan::buffered_chan<std::string> c(3);

	std::thread t([&](){
		std::string x;

		c >> x;
		ASSERT_STREQ("buffered", x.c_str());

		c >> x;
		ASSERT_STREQ("chan", x.c_str());

		c >> x;
		ASSERT_STREQ("test", x.c_str());
	});

	c << "buffered" << "chan" << "test";

	t.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x170(%rbp)
movl $0x3, %esi
callq 0x4c520
movq -0x170(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x46c30
jmp 0x469aa
leaq -0xc8(%rbp), %rax
movq %rax, -0x180(%rbp)
leaq -0x111(%rbp), %rdi
movq %rdi, -0x178(%rbp)
callq 0xabd0
movq -0x178(%rbp), %rdx
leaq 0xce87(%rip), %rsi      # 0x53860
leaq -0x110(%rbp), %rdi
callq 0xa950
jmp 0x469e7
movq -0x180(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x4c300
movq %rax, -0x188(%rbp)
jmp 0x46a03
leaq -0x139(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0xabd0
movq -0x190(%rbp), %rdx
leaq 0xce17(%rip), %rsi      # 0x5383b
leaq -0x138(%rbp), %rdi
callq 0xa950
jmp 0x46a32
movq -0x188(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x138(%rbp), %rsi
callq *%rax
movq %rax, -0x198(%rbp)
jmp 0x46a52
leaq -0x161(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0xabd0
movq -0x1a0(%rbp), %rdx
leaq 0xbc14(%rip), %rsi      # 0x52687
leaq -0x160(%rbp), %rdi
callq 0xa950
jmp 0x46a81
movq -0x198(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x160(%rbp), %rsi
callq *%rax
jmp 0x46a9a
leaq -0x160(%rbp), %rdi
callq 0xad58
leaq -0x161(%rbp), %rdi
callq 0xa680
leaq -0x138(%rbp), %rdi
callq 0xad58
leaq -0x139(%rbp), %rdi
callq 0xa680
leaq -0x110(%rbp), %rdi
callq 0xad58
leaq -0x111(%rbp), %rdi
callq 0xa680
leaq -0xd8(%rbp), %rdi
callq 0xab70
jmp 0x46af0
leaq -0xd8(%rbp), %rdi
callq 0x4c1f0
leaq -0xd0(%rbp), %rdi
callq 0x4c5f0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x46c09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x46bdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x46bd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x46bc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x46bb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x46bad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0x160(%rbp), %rdi
callq 0xad58
leaq -0x161(%rbp), %rdi
callq 0xa680
leaq -0x138(%rbp), %rdi
callq 0xad58
leaq -0x139(%rbp), %rdi
callq 0xa680
leaq -0x110(%rbp), %rdi
callq 0xad58
leaq -0x111(%rbp), %rdi
callq 0xa680
jmp 0x46bfd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4c1f0
leaq -0xd0(%rbp), %rdi
callq 0x4c5f0
movq -0xe8(%rbp), %rdi
callq 0xabc0
nopw %cs:(%rax,%rax)
// File: suyash[P]chan/chan_test.cc
// Function: unbuffered_chan_communication_test_Test::TestBody()
TEST(unbuffered_chan, communication_test) {
	std::string a = "not hello, world";
	chan::unbuffered_chan<int> c;

	auto f = [&]() {
		a = "hello, world";

		int _ = 0;
		c >> _;
	};

	std::thread t(f);
	c << 0;

	ASSERT_STREQ("hello, world", a.c_str());

	t.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0xabd0
movq -0x190(%rbp), %rdx
leaq 0xcb6f(%rip), %rsi      # 0x5387c
leaq -0x28(%rbp), %rdi
callq 0xa950
jmp 0x46d18
leaq -0x29(%rbp), %rdi
callq 0xa680
leaq -0x140(%rbp), %rdi
callq 0x4c150
jmp 0x46d2f
leaq -0x28(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x140(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq -0x158(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0x46f80
jmp 0x46d5d
leaq -0x138(%rbp), %rdi
movl $0x0, -0x15c(%rbp)
leaq -0x15c(%rbp), %rsi
callq 0x4c1c0
jmp 0x46d7c
leaq -0x28(%rbp), %rdi
callq 0xa230
movq %rax, %r8
leaq 0xcafe(%rip), %rsi      # 0x5388d
leaq 0xcb06(%rip), %rdx      # 0x5389c
leaq 0xcae3(%rip), %rcx      # 0x53880
leaq -0x170(%rbp), %rdi
callq 0x12700
jmp 0x46dab
leaq -0x170(%rbp), %rdi
callq 0x29610
movb %al, -0x191(%rbp)
jmp 0x46dbf
movb -0x191(%rbp), %al
testb $0x1, %al
jne 0x46dcb
jmp 0x46e2e
jmp 0x46ee4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0xa680
jmp 0x46f75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x46f6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x46f60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x46f54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x46f48
leaq -0x178(%rbp), %rdi
callq 0xf670
jmp 0x46e3c
leaq -0x170(%rbp), %rdi
callq 0x29630
movq %rax, -0x1a0(%rbp)
jmp 0x46e51
movq -0x1a0(%rbp), %r8
leaq 0xc9ea(%rip), %rdx      # 0x53849
leaq -0x180(%rbp), %rdi
movl $0x2, %esi
movl $0x6b, %ecx
callq 0xc8a0
jmp 0x46e77
leaq -0x180(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0xc960
jmp 0x46e8c
leaq -0x180(%rbp), %rdi
callq 0xc920
leaq -0x178(%rbp), %rdi
callq 0x295f0
movl $0x1, -0x184(%rbp)
jmp 0x46eee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x46ed6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xc920
leaq -0x178(%rbp), %rdi
callq 0x295f0
jmp 0x46f48
movl $0x0, -0x184(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x292a0
movl -0x184(%rbp), %eax
testl %eax, %eax
jne 0x46f1e
jmp 0x46f06
leaq -0x158(%rbp), %rdi
callq 0xab70
jmp 0x46f14
movl $0x0, -0x184(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x4c1f0
leaq -0x140(%rbp), %rdi
callq 0x4c220
leaq -0x28(%rbp), %rdi
callq 0xad58
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
leaq -0x170(%rbp), %rdi
callq 0x292a0
leaq -0x158(%rbp), %rdi
callq 0x4c1f0
leaq -0x140(%rbp), %rdi
callq 0x4c220
leaq -0x28(%rbp), %rdi
callq 0xad58
movq -0x38(%rbp), %rdi
callq 0xabc0
nop
// File: suyash[P]chan/chan_test.cc
// Function: buffered_chan_multi_Test::TestBody()
TEST(buffered_chan, multi) {
	chan::buffered_chan<int> c(5);

	std::thread pool[100];

	auto sender = [](chan::write_chan<int>& c){
		c << 1;
	};

	for (int i = 0 ; i < 50 ; i++) {
		pool[i] = std::thread(sender, std::ref(c));
	}

	auto receiver = [](chan::read_chan<int>& c){
		int _ = 0;
		c >> _;
	};

	for (int i = 50 ; i < 100 ; i++) {
		pool[i] = std::thread(receiver, std::ref(c));
	}

	for (int i = 0 ; i < 100 ; i++) {
		pool[i].join();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp            # imm = 0x480
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rdi
movl $0x5, %esi
callq 0x4c3c0
leaq -0x3f0(%rbp), %rax
movq %rax, %rcx
addq $0x320, %rcx            # imm = 0x320
movq %rcx, -0x448(%rbp)
movq %rax, -0x440(%rbp)
movq -0x440(%rbp), %rdi
movq %rdi, -0x450(%rbp)
callq 0x4c730
movq -0x450(%rbp), %rax
movq -0x448(%rbp), %rcx
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, -0x440(%rbp)
jne 0x473df
movl $0x0, -0x3f8(%rbp)
cmpl $0x32, -0x3f8(%rbp)
jge 0x474c6
leaq -0xd0(%rbp), %rdi
callq 0x4c750
movq %rax, -0x408(%rbp)
leaq -0x400(%rbp), %rdi
leaq -0x3f1(%rbp), %rsi
leaq -0x408(%rbp), %rdx
callq 0x47630
jmp 0x47456
movslq -0x3f8(%rbp), %rax
leaq -0x3f0(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x400(%rbp), %rsi
callq 0x4c780
leaq -0x400(%rbp), %rdi
callq 0x4c1f0
movl -0x3f8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3f8(%rbp)
jmp 0x4741a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x410(%rbp)
movl %eax, -0x414(%rbp)
leaq -0x3f0(%rbp), %rax
movq %rax, -0x460(%rbp)
addq $0x320, %rax            # imm = 0x320
movq %rax, -0x458(%rbp)
jmp 0x475e3
movl $0x32, -0x41c(%rbp)
cmpl $0x64, -0x41c(%rbp)
jge 0x47546
leaq -0xd0(%rbp), %rdi
callq 0x4c750
movq %rax, -0x430(%rbp)
leaq -0x428(%rbp), %rdi
leaq -0x415(%rbp), %rsi
leaq -0x430(%rbp), %rdx
callq 0x476f0
jmp 0x47508
movslq -0x41c(%rbp), %rax
leaq -0x3f0(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x428(%rbp), %rsi
callq 0x4c780
leaq -0x428(%rbp), %rdi
callq 0x4c1f0
movl -0x41c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x41c(%rbp)
jmp 0x474d0
movl $0x0, -0x434(%rbp)
cmpl $0x64, -0x434(%rbp)
jge 0x47582
movslq -0x434(%rbp), %rax
leaq -0x3f0(%rbp,%rax,8), %rdi
callq 0xab70
jmp 0x4756f
jmp 0x47571
movl -0x434(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x434(%rbp)
jmp 0x47550
leaq -0x3f0(%rbp), %rax
movq %rax, -0x470(%rbp)
addq $0x320, %rax            # imm = 0x320
movq %rax, -0x468(%rbp)
movq -0x468(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x478(%rbp)
callq 0x4c1f0
movq -0x470(%rbp), %rcx
movq -0x478(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x468(%rbp)
jne 0x4759d
leaq -0xd0(%rbp), %rdi
callq 0x4c490
addq $0x480, %rsp            # imm = 0x480
popq %rbp
retq
movq -0x458(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x480(%rbp)
callq 0x4c1f0
movq -0x460(%rbp), %rcx
movq -0x480(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x458(%rbp)
jne 0x475e3
leaq -0xd0(%rbp), %rdi
callq 0x4c490
movq -0x410(%rbp), %rdi
callq 0xabc0
nopl (%rax)
// File: suyash[P]chan/chan_test.cc
// Function: unbuffered_chan_multi_Test::TestBody()
TEST(unbuffered_chan, multi) {
	chan::unbuffered_chan<int> c;

	std::thread pool[100];

	auto sender = [](chan::write_chan<int>& c){
		c << 1;
	};

	for (int i = 0 ; i < 50 ; i++) {
		pool[i] = std::thread(sender, std::ref(c));
	}

	auto receiver = [](chan::read_chan<int>& c){
		int _ = 0;
		c >> _;
	};

	for (int i = 50 ; i < 100 ; i++) {
		pool[i] = std::thread(receiver, std::ref(c));
	}

	for (int i = 0 ; i < 100 ; i++) {
		pool[i].join();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp            # imm = 0x4C0
movq %rdi, -0x8(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x4c150
leaq -0x430(%rbp), %rax
movq %rax, %rcx
addq $0x320, %rcx            # imm = 0x320
movq %rcx, -0x488(%rbp)
movq %rax, -0x480(%rbp)
movq -0x480(%rbp), %rdi
movq %rdi, -0x490(%rbp)
callq 0x4c730
movq -0x490(%rbp), %rax
movq -0x488(%rbp), %rcx
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, -0x480(%rbp)
jne 0x477ea
movl $0x0, -0x438(%rbp)
cmpl $0x32, -0x438(%rbp)
jge 0x478d1
leaq -0x108(%rbp), %rdi
callq 0x4c800
movq %rax, -0x448(%rbp)
leaq -0x440(%rbp), %rdi
leaq -0x431(%rbp), %rsi
leaq -0x448(%rbp), %rdx
callq 0x47a40
jmp 0x47861
movslq -0x438(%rbp), %rax
leaq -0x430(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x440(%rbp), %rsi
callq 0x4c780
leaq -0x440(%rbp), %rdi
callq 0x4c1f0
movl -0x438(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x438(%rbp)
jmp 0x47825
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x450(%rbp)
movl %eax, -0x454(%rbp)
leaq -0x430(%rbp), %rax
movq %rax, -0x4a0(%rbp)
addq $0x320, %rax            # imm = 0x320
movq %rax, -0x498(%rbp)
jmp 0x479ee
movl $0x32, -0x45c(%rbp)
cmpl $0x64, -0x45c(%rbp)
jge 0x47951
leaq -0x108(%rbp), %rdi
callq 0x4c800
movq %rax, -0x470(%rbp)
leaq -0x468(%rbp), %rdi
leaq -0x455(%rbp), %rsi
leaq -0x470(%rbp), %rdx
callq 0x47b00
jmp 0x47913
movslq -0x45c(%rbp), %rax
leaq -0x430(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x468(%rbp), %rsi
callq 0x4c780
leaq -0x468(%rbp), %rdi
callq 0x4c1f0
movl -0x45c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x45c(%rbp)
jmp 0x478db
movl $0x0, -0x474(%rbp)
cmpl $0x64, -0x474(%rbp)
jge 0x4798d
movslq -0x474(%rbp), %rax
leaq -0x430(%rbp,%rax,8), %rdi
callq 0xab70
jmp 0x4797a
jmp 0x4797c
movl -0x474(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x474(%rbp)
jmp 0x4795b
leaq -0x430(%rbp), %rax
movq %rax, -0x4b0(%rbp)
addq $0x320, %rax            # imm = 0x320
movq %rax, -0x4a8(%rbp)
movq -0x4a8(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x4b8(%rbp)
callq 0x4c1f0
movq -0x4b0(%rbp), %rcx
movq -0x4b8(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x4a8(%rbp)
jne 0x479a8
leaq -0x108(%rbp), %rdi
callq 0x4c220
addq $0x4c0, %rsp            # imm = 0x4C0
popq %rbp
retq
movq -0x498(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x4c0(%rbp)
callq 0x4c1f0
movq -0x4a0(%rbp), %rcx
movq -0x4c0(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x498(%rbp)
jne 0x479ee
leaq -0x108(%rbp), %rdi
callq 0x4c220
movq -0x450(%rbp), %rdi
callq 0xabc0
nopw (%rax,%rax)
// File: suyash[P]chan/./chan.hh
// Function: chan::buffered_chan<int>::read(int&)
bool read(T& valref) {
		std::unique_lock<std::mutex> data_lock(this->data_mutex);

		while (data.empty()) {
			if (this->is_closed) {
				// TODO: figure out error handling here
				valref = T();
				return false;
			}

			this->read_wait_count++;
			this->read_available.wait(data_lock);
			this->read_wait_count--;
		}

		valref = data.front();
		data.pop();

		if (this->write_wait_count > 0) {
			this->write_available.notify_one();
		}

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x40(%rbp)
addq $0x18, %rsi
leaq -0x28(%rbp), %rdi
callq 0x4d040
movq -0x40(%rbp), %rdi
addq $0xb0, %rdi
callq 0x4dbb0
movb %al, -0x41(%rbp)
jmp 0x4d94a
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x4d953
jmp 0x4d9bd
movq -0x40(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x4d991
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x4da0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4d0c0
jmp 0x4da23
movq -0x40(%rbp), %rdi
movl 0x40(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x40(%rdi)
addq $0x48, %rdi
leaq -0x28(%rbp), %rsi
callq 0xa190
movq -0x40(%rbp), %rax
movl 0x40(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x40(%rax)
jmp 0x4d935
movq -0x40(%rbp), %rdi
addq $0xb0, %rdi
callq 0x4dbd0
movl %eax, -0x48(%rbp)
jmp 0x4d9d2
movq -0x40(%rbp), %rdi
movl -0x48(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0xb0, %rdi
callq 0x4dc10
jmp 0x4d9ed
movq -0x40(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jle 0x4da04
movq -0x40(%rbp), %rdi
addq $0x78, %rdi
callq 0xa2c0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4d0c0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xabc0
nopl (%rax)
// File: suyash[P]chan/./chan.hh
// Function: chan::buffered_chan<int>::write(int const&)
void write(const T& val) {
		std::unique_lock<std::mutex> data_lock(this->data_mutex);

		while (!this->is_closed && data.size() == capacity) {
			this->write_wait_count++;
			this->write_available.wait(data_lock);
			this->write_wait_count--;
		}

		if (this->is_closed) {
			throw _closed_channel_write_exception;
		}

		data.push(val);

		// signal waiting reader
		if (this->read_wait_count > 0) {
			this->read_available.notify_one();
		}

		// NOTE: this doesn't immediately block for read
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x18, %rsi
leaq -0x20(%rbp), %rdi
callq 0x4d040
movq -0x38(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x10(%rcx)
movb %al, -0x39(%rbp)
jne 0x4dabc
movq -0x38(%rbp), %rdi
addq $0xb0, %rdi
callq 0x4dc60
movl %eax, -0x40(%rbp)
jmp 0x4daa9
movl -0x40(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0xa8(%rcx), %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x4dac5
jmp 0x4db05
movq -0x38(%rbp), %rdi
movl 0x44(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x44(%rdi)
addq $0x78, %rdi
leaq -0x20(%rbp), %rsi
callq 0xa190
movq -0x38(%rbp), %rax
movl 0x44(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x44(%rax)
jmp 0x4da85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4d0c0
jmp 0x4db81
movq -0x38(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x4db45
movl $0x8, %edi
callq 0xa2b0
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
leaq 0x29de1(%rip), %rsi     # 0x77908
callq 0x4d7c0
movq -0x48(%rbp), %rdi
leaq 0x28ae1(%rip), %rsi     # 0x76618
leaq -0x1b0e(%rip), %rdx     # 0x4c030
callq 0xab80
jmp 0x4db8a
movq -0x38(%rbp), %rdi
addq $0xb0, %rdi
movq -0x10(%rbp), %rsi
callq 0x4dc80
jmp 0x4db5b
movq -0x38(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jle 0x4db72
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
callq 0xa2c0
leaq -0x20(%rbp), %rdi
callq 0x4d0c0
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xabc0
nopw (%rax,%rax)
// File: suyash[P]chan/./circular_queue.hh
// Function: chan::circular_queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::front()
T front() {
		if (filled == 0) {
			// TODO: figure out error handling here
			return T(0);
		}

		return data[f];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x4(%rax)
jne 0x4e1cb
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xabd0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xa950
jmp 0x4e1a9
leaq -0x11(%rbp), %rdi
callq 0xa680
jmp 0x4e1e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0xa680
jmp 0x4e1f1
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
movslq 0x8(%rax), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0xa240
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xabc0
nopw (%rax,%rax)
// File: suyash[P]chan/./circular_queue.hh
// Function: chan::circular_queue<int>::pop()
bool pop() {
		if (filled == 0) {
			// TODO: figure out error handling here
			return false;
		}

		f = (f + 1) % capacity;
		filled--;
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x4(%rax)
jne 0x4dc2c
movb $0x0, -0x1(%rbp)
jmp 0x4dc4d
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %eax
addl $0x1, %eax
cltd
idivl (%rcx)
movq -0x18(%rbp), %rax
movl %edx, 0x8(%rax)
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: suyash[P]chan/./circular_queue.hh
// Function: chan::circular_queue<int>::push(int const&)
bool push(const T& val) {
		if (filled == capacity) {
			// TODO: figure out error handling here
			return false;
		}

		b = (b + 1) % capacity;
		data[b] = val;

		filled++;
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jne 0x4dca1
movb $0x0, -0x1(%rbp)
jmp 0x4dcd3
movq -0x20(%rbp), %rcx
movl 0xc(%rcx), %eax
addl $0x1, %eax
cltd
idivl (%rcx)
movq -0x20(%rbp), %rax
movl %edx, 0xc(%rax)
movq -0x18(%rbp), %rcx
movl (%rcx), %esi
movq 0x10(%rax), %rcx
movslq 0xc(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: Se6[P]CmdLineArgs/./CmdLineArgs.h
// Function: CmdLineArgs::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> CmdLineArgs::split(const std::string &s, char delim)
{
    std::vector<std::string> elems;
    std::stringstream ss(s);
    std::string item;

    while(getline(ss, item, delim))
        elems.push_back(item);

    return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f0(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x7600
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x7620
movl %eax, -0x1d4(%rbp)
jmp 0x3714
movl -0x1d4(%rbp), %edx
movq -0x1e0(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x3440
jmp 0x372f
leaq -0x1d0(%rbp), %rdi
callq 0x3400
movsbl -0x11(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x3530
movq %rax, -0x1f8(%rbp)
jmp 0x375b
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x33b0
movb %al, -0x1f9(%rbp)
jmp 0x3779
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0x3785
jmp 0x37dc
movq -0x1f0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x7640
jmp 0x379a
jmp 0x373b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x381a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x31d0
leaq -0x1a0(%rbp), %rdi
callq 0x3260
jmp 0x381a
movb $0x1, -0x12(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x31d0
leaq -0x1a0(%rbp), %rdi
callq 0x3260
testb $0x1, -0x12(%rbp)
jne 0x380a
movq -0x1f0(%rbp), %rdi
callq 0x76b0
movq -0x1e8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1f0(%rbp), %rdi
callq 0x76b0
movq -0x1a8(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: Se6[P]CmdLineArgs/./CmdLineArgs.h
// Function: CmdLineArgs::findLongName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::string>::iterator CmdLineArgs::findLongName(const std::string &name)
{
    std::vector<std::string>::iterator pos;
    bool found = false;

    for( pos=args_.begin(); pos!=args_.end(); ++pos ) {

        if( pos->size()<3 || pos->substr(0,2) != "--")
            continue;

        if( pos->substr(2) == name.substr(0,pos->size()-2) ){
            found = true;
            break;
        }
    }

    return found ? pos : args_.end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7ae0
movq -0xb8(%rbp), %rdi
movb $0x0, -0x21(%rbp)
callq 0x7a20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x79b0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7b00
testb $0x1, %al
jne 0x3bf9
jmp 0x3d98
leaq -0x20(%rbp), %rdi
callq 0x7b40
movq %rax, %rdi
callq 0x3200
movq %rax, %rcx
movb $0x0, -0x59(%rbp)
movb $0x1, %al
cmpq $0x3, %rcx
movb %al, -0xb9(%rbp)
jb 0x3c71
leaq -0x20(%rbp), %rdi
callq 0x7b40
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x2, %ecx
callq 0x3310
movq -0xc8(%rbp), %rdi
movb $0x1, -0x59(%rbp)
leaq 0xc3d4(%rip), %rsi      # 0x1002a
callq 0x7b60
movb %al, -0xba(%rbp)
jmp 0x3c63
movb -0xba(%rbp), %al
movb %al, -0xb9(%rbp)
jmp 0x3c71
movb -0xb9(%rbp), %al
movb %al, -0xc9(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x3c85
jmp 0x3c8e
leaq -0x58(%rbp), %rdi
callq 0x31d0
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x3c9a
jmp 0x3cc1
jmp 0x3d8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x3cb3
jmp 0x3cbc
leaq -0x58(%rbp), %rdi
callq 0x31d0
jmp 0x3dc5
leaq -0x20(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x7b40
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movl $0x2, %edx
movq $-0x1, %rcx
callq 0x3310
movq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
callq 0x7b40
movq %rax, %rdi
callq 0x3200
movq -0xd8(%rbp), %rsi
movq %rax, %rcx
addq $-0x2, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0xb0(%rbp), %rdi
callq 0x3310
jmp 0x3d2b
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x7b90
movb %al, -0xe1(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x31d0
leaq -0x90(%rbp), %rdi
callq 0x31d0
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0x3d68
jmp 0x3d88
movb $0x1, -0x21(%rbp)
jmp 0x3d98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x31d0
jmp 0x3dc5
jmp 0x3d8a
leaq -0x20(%rbp), %rdi
callq 0x7c20
jmp 0x3bd3
testb $0x1, -0x21(%rbp)
je 0x3da8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3db8
movq -0xb8(%rbp), %rdi
callq 0x79b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x34e0
nop
// File: Se6[P]CmdLineArgs/./CmdLineArgs.h
// Function: CmdLineArgs::findShortName[abi:cxx11](char)
std::vector<std::string>::iterator CmdLineArgs::findShortName(char name)
{
    if(name==' ')
        return args_.end();

    std::vector<std::string>::iterator pos;
    bool found = false;

    for(pos=args_.begin(); pos!=args_.end(); ++pos){

        if( pos->size()<2 || (*pos)[0] != '-')
            continue;

        if((*pos)[1] == '-')
            continue;

        std::string::size_type idx = pos->find(name,1);
        if( idx != std::string::npos ) {
            found = true;
            break;
        }
    }

    return found ? pos : args_.end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
jne 0x3e05
movq -0x48(%rbp), %rdi
callq 0x79b0
movq %rax, -0x8(%rbp)
jmp 0x3efa
leaq -0x20(%rbp), %rdi
callq 0x7ae0
movq -0x48(%rbp), %rdi
movb $0x0, -0x21(%rbp)
callq 0x7a20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rdi
callq 0x79b0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7b00
testb $0x1, %al
jne 0x3e4a
jmp 0x3edb
leaq -0x20(%rbp), %rdi
callq 0x7b40
movq %rax, %rdi
callq 0x3200
cmpq $0x2, %rax
jb 0x3e7e
leaq -0x20(%rbp), %rdi
callq 0x7c40
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3570
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x3e80
jmp 0x3ecd
leaq -0x20(%rbp), %rdi
callq 0x7c40
movq %rax, %rdi
movl $0x1, %esi
callq 0x3570
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x3ea0
jmp 0x3ecd
leaq -0x20(%rbp), %rdi
callq 0x7b40
movq %rax, %rdi
movl $0x1, %edx
movsbl -0x11(%rbp), %esi
callq 0x33e0
movq %rax, -0x40(%rbp)
cmpq $-0x1, -0x40(%rbp)
je 0x3ecb
movb $0x1, -0x21(%rbp)
jmp 0x3edb
jmp 0x3ecd
leaq -0x20(%rbp), %rdi
callq 0x7c20
jmp 0x3e27
testb $0x1, -0x21(%rbp)
je 0x3eeb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3ef8
movq -0x48(%rbp), %rdi
callq 0x79b0
movq %rax, -0x8(%rbp)
jmp 0x3efa
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Se6[P]CmdLineArgs/./CmdLineArgs.h
// Function: CmdLineArgs::getUnparsedOpts[abi:cxx11]()
std::vector<std::string> CmdLineArgs::getUnparsedOpts()
{
    std::vector<std::string> unparsed;
    for( auto &arg: args_ )
        if( arg[0] == '-' )
            unparsed.push_back(arg);
    return unparsed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7600
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7a20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x79b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7b00
testb $0x1, %al
jne 0x5e41
jmp 0x5ea2
leaq -0x28(%rbp), %rdi
callq 0x7c40
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3570
movq %rax, -0x68(%rbp)
jmp 0x5e61
movq -0x68(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x5e95
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x7640
jmp 0x5e7c
jmp 0x5e95
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x76b0
jmp 0x5ebf
jmp 0x5e97
leaq -0x28(%rbp), %rdi
callq 0x7c20
jmp 0x5e2e
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5eb5
movq -0x60(%rbp), %rdi
callq 0x76b0
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34e0
nopl (%rax,%rax)