LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Tile_Structure/TileStack.cpp
// Function: TileStack::TileStack()
TileStack::TileStack()
{
	for (int i = 1; i < 29; i++)
	{
		Tile tile(i);
		if (i == 1 || i == 4 || i == 8 || i == 15 || i == 22 || i == 17 || i == 21 || i == 26)
		{
			for(int k = 0; k < 1; k++) { tiles.push_back(tile); }
		}
		if (i == 3 || i == 14 || i == 16 || i == 18 || i == 19 || i == 20 || i == 23 || i == 25 || i == 27 || i == 28)
		{
			for(int k = 0; k < 2; k++) { tiles.push_back(tile); }
		}
		if (i == 11 || i == 12 || i == 24)
		{
			for(int k = 0; k < 3; k++) { tiles.push_back(tile); }
		}
		if (i == 2 || i == 7 || i == 9)
		{
			for(int k = 0; k < 4; k++) { tiles.push_back(tile); }
		}
		if (i == 10 || i == 13)
		{
			for(int k = 0; k < 5; k++) { tiles.push_back(tile); }
		}
		if (i == 5)
		{
			for(int k = 0; k < 8; k++) { tiles.push_back(tile); }
		}
		if (i == 6)
		{
			for(int k = 0; k < 9; k++) { tiles.push_back(tile); }
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x1, %r14d
leaq -0x110(%rbp), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x158a8
movl %r14d, %eax
andl $0x1b, %eax
cmpl $0x11, %eax
je 0x14f65
cmpl $0x1a, %r14d
ja 0x14f70
movl $0x4408112, %eax        # imm = 0x4408112
btl %r14d, %eax
jae 0x14f70
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15276
cmpl $0x1c, %r14d
je 0x14fa1
movl %r14d, %eax
andl $0x1d, %eax
cmpl $0x19, %eax
je 0x14fa1
cmpl $0x17, %r14d
je 0x14fa1
leal -0x13(%r14), %ecx
cmpl $0x2, %ecx
jb 0x14fa1
cmpl $0x3, %r14d
je 0x14fa1
cmpl $0xe, %r14d
je 0x14fa1
cmpl $0x10, %eax
jne 0x14fb7
movl $0x1, %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15276
decl %r13d
je 0x14fa7
leal -0x2(%r14), %r13d
cmpl $0x16, %r13d
ja 0x15088
leaq 0x3998(%rip), %rcx      # 0x18964
movslq (%rcx,%r13,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15276
decl %r12d
jne 0x14fdb
cmpl $0xb, %r13d
ja 0x15088
leaq 0x39c4(%rip), %rcx      # 0x189c0
movslq (%rcx,%r13,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15276
decl %r12d
jne 0x1500b
leal -0x5(%r14), %eax
cmpl $0x8, %eax
ja 0x15088
leaq 0x39c5(%rip), %rcx      # 0x189f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x5, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15276
decl %r12d
jne 0x1503a
cmpl $0x6, %r14d
je 0x15072
cmpl $0x5, %r14d
jne 0x15088
movl $0x8, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15276
decl %r12d
jne 0x1505c
cmpl $0x6, %r14d
jne 0x15088
movl $0x9, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15276
decl %r12d
jne 0x15078
movq %r15, %rdi
callq 0x16aa0
incl %r14d
cmpl $0x1d, %r14d
jne 0x14f3e
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x150c0
movq %rax, %r14
jmp 0x150cf
jmp 0x150c0
jmp 0x150c0
jmp 0x150c0
jmp 0x150c0
jmp 0x150c0
movq %rax, %r14
leaq -0x110(%rbp), %rdi
callq 0x16aa0
movq %rbx, %rdi
callq 0x152b4
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Tile_Structure/Tile.cpp
// Function: Tile::setFaceTypes()
void Tile::setFaceTypes() {
  upFace.setType(innerBlocks[0][1].getType());
  downFace.setType(innerBlocks[2][1].getType());
  leftFace.setType(innerBlocks[1][0].getType());
  rightFace.setType(innerBlocks[1][2].getType());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq 0xd0(%rdi), %rax
movq (%rax), %rax
leaq -0x90(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
callq 0x9da8
movq %r14, %rdi
movq %r15, %rsi
callq 0x1771e
movq -0xa0(%rbp), %rdi
cmpq %r12, %rdi
je 0x168cb
callq 0x3200
leaq 0x38(%rbx), %r14
movq 0xd0(%rbx), %rax
movq 0x30(%rax), %rax
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x9da8
movq %r14, %rdi
movq %r15, %rsi
callq 0x1771e
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x16913
callq 0x3200
leaq 0x60(%rbx), %r14
movq 0xd0(%rbx), %rax
movq 0x18(%rax), %rax
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x9da8
movq %r14, %rdi
movq %r15, %rsi
callq 0x1771e
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x1695b
callq 0x3200
movq 0xd0(%rbx), %rax
addq $0x88, %rbx
movq 0x18(%rax), %rax
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x58(%rax), %rsi
movq 0x60(%rax), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x9da8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1771e
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x169a5
callq 0x3200
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
jne 0x169e4
jmp 0x169e9
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x169df
movq %rax, %rbx
movq -0x80(%rbp), %rdi
jmp 0x169df
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
cmpq %r12, %rdi
je 0x169e9
callq 0x3200
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Tile_Structure/Tile.cpp
// Function: Tile::Tile()
Tile::Tile()
{
  rotation = 0;
  num = 0;
  boar = false;
  buffalo = false;
  deer = false;
  crocodile = false;
  type = '.';
	initialization = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x176dc
leaq 0x38(%r15), %r14
movq %r14, %rdi
callq 0x176dc
leaq 0x60(%r15), %r12
movq %r12, %rdi
callq 0x176dc
leaq 0x88(%r15), %rdi
callq 0x176dc
xorl %eax, %eax
movq %rax, (%r15)
movl $0x0, 0x9(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%r15)
movups %xmm0, 0xc0(%r15)
movups %xmm0, 0xd0(%r15)
movq %rax, 0xe0(%r15)
movb $0x2e, 0x8(%r15)
movb $0x0, 0xd(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x176f8
jmp 0x16a82
movq %rax, %r15
movq %r14, %rdi
callq 0x176f8
jmp 0x16a8f
movq %rax, %r15
movq %rbx, %rdi
callq 0x176f8
movq %r15, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Tile_Structure/Tile.cpp
// Function: Tile::getOpenFaces[abi:cxx11]()
std::vector<std::string> Tile::getOpenFaces()
{
	std::vector<std::string> openFaces;
	if(!upFace.connected())
		openFaces.push_back("up");
	if(!downFace.connected())
		openFaces.push_back("down");
	if(!leftFace.connected())
		openFaces.push_back("left");
	if(!rightFace.connected())
		openFaces.push_back("right");
	return openFaces;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x10(%rsi), %rdi
callq 0x177da
testb %al, %al
jne 0x1703b
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x186c(%rip), %rsi      # 0x1887d
leaq 0x1867(%rip), %rdx      # 0x1887f
leaq -0x38(%rbp), %rdi
callq 0x9e42
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x17484
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1703b
callq 0x3200
leaq 0x38(%r14), %rdi
callq 0x177da
testb %al, %al
jne 0x17081
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1829(%rip), %rsi      # 0x18880
leaq 0x1826(%rip), %rdx      # 0x18884
leaq -0x38(%rbp), %rdi
callq 0x9e42
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x17484
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x17081
callq 0x3200
leaq 0x60(%r14), %rdi
callq 0x177da
testb %al, %al
jne 0x170c7
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x17e8(%rip), %rsi      # 0x18885
leaq 0x17e5(%rip), %rdx      # 0x18889
leaq -0x38(%rbp), %rdi
callq 0x9e42
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x17484
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x170c7
callq 0x3200
addq $0x88, %r14
movq %r14, %rdi
callq 0x177da
testb %al, %al
jne 0x17113
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x17a1(%rip), %rsi      # 0x1888a
leaq 0x179f(%rip), %rdx      # 0x1888f
leaq -0x38(%rbp), %rdi
callq 0x9e42
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x17484
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x17113
callq 0x3200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1712d
jmp 0x17142
jmp 0x1712d
jmp 0x17142
jmp 0x1712d
jmp 0x17142
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x17145
callq 0x3200
jmp 0x17145
jmp 0x17142
movq %rax, %r14
movq %rbx, %rdi
callq 0xc6c8
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Tile_Structure/Block.cpp
// Function: Block::Block(char)
Block::Block(char c)
{
  if (c == Jungle)
  	type = "jungle";
  else if (c == Lake)
  	type = "lake";
  else if (c == Trail)
  	type = "trail";
  else if (c == Den)
	  type = "den";
  else if (c == Mixed)
	  type = "mixed";
  else
  	type = "";
  visited = false;
  meeple = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leal -0x64(%rsi), %eax
cmpl $0x9, %eax
ja 0x17834
leaq 0x129c(%rip), %rcx      # 0x18ab8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, %r8d
leaq 0xf64(%rip), %rcx       # 0x18796
jmp 0x1787f
cmpl $0x74, %esi
jne 0x17848
movl $0x5, %r8d
leaq 0xf71(%rip), %rcx       # 0x187b7
jmp 0x1787f
leaq 0xf46(%rip), %rcx       # 0x18795
xorl %r8d, %r8d
jmp 0x1787f
movl $0x4, %r8d
leaq 0xf51(%rip), %rcx       # 0x187b2
jmp 0x1787f
movl $0x5, %r8d
leaq 0x1024(%rip), %rcx      # 0x18894
jmp 0x1787f
movl $0x6, %r8d
leaq 0xf2c(%rip), %rcx       # 0x187ab
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3370
movw $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x178ac
callq 0x3200
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Tile_Structure/Block.cpp
// Function: Block::setType(char)
void Block::setType(char c) {
  if (c == Jungle)
    type = "jungle";
  else if (c == Lake)
    type = "lake";
  else if (c == Trail)
    type = "trail";
  else if (c == Den)
    type = "den";
  else if (c == Mixed)
	  type = "mixed";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x64(%rsi), %eax
cmpl $0x9, %eax
ja 0x17961
leaq 0x119f(%rip), %rcx      # 0x18ae0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rdi), %rdx
addq $0x8, %rdi
leaq 0xe3d(%rip), %rcx       # 0x18796
movl $0x3, %r8d
jmp 0x179bc
cmpl $0x74, %esi
jne 0x17977
movq 0x10(%rdi), %rdx
addq $0x8, %rdi
leaq 0xe42(%rip), %rcx       # 0x187b7
jmp 0x1799f
popq %rbp
retq
movq 0x10(%rdi), %rdx
addq $0x8, %rdi
leaq 0xe2a(%rip), %rcx       # 0x187b2
movl $0x4, %r8d
jmp 0x179bc
movq 0x10(%rdi), %rdx
addq $0x8, %rdi
leaq 0xef5(%rip), %rcx       # 0x18894
movl $0x5, %r8d
jmp 0x179bc
movq 0x10(%rdi), %rdx
addq $0x8, %rdi
leaq 0xdf5(%rip), %rcx       # 0x187ab
movl $0x6, %r8d
xorl %esi, %esi
popq %rbp
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Tile_Structure/Structure.cpp
// Function: Structure::Structure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<int, int>)
Structure::Structure(std::string type, std::pair<int,int> blockCoords) {
	this->type = type;
	this->startingBlock = blockCoords;
	this->boarCount = 0;
	this->deerCount = 0;
	this->buffaloCount = 0;
	this->crocodileCount = 0;
	this->hasMeeple = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
callq 0x3140
movq %r14, %rax
shrq $0x20, %rax
movl %r14d, 0x20(%rbx)
movl %eax, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movb $0x0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rbx), %rdi
callq 0x90e2
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x17a40
callq 0x3200
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Tile_Structure/Structure.cpp
// Function: Structure::Structure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Structure::Structure(std::string type) {
	this->type = type;
	this->boarCount = 0;
	this->deerCount = 0;
	this->buffaloCount = 0;
	this->crocodileCount = 0;
	this->hasMeeple = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
callq 0x3140
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movb $0x0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rbx), %rdi
callq 0x90e2
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x17aa7
callq 0x3200
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Doug0855[P]TigerZone/Tile_Structure/Structure.cpp
// Function: Structure::checkAnimals(Tile*)
void Structure::checkAnimals(Tile *tile) {
	if(tile->hasCrocodile())
		this->crocodileCount++;
	if(tile->hasDeer())
		this->deerCount++;
	if(tile->hasBoar())
		this->boarCount++;
	if(tile->hasBuffalo())
		this->buffaloCount++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0xc(%rsi)
jne 0x17b11
incl 0x4c(%rdi)
cmpb $0x1, 0xb(%rsi)
jne 0x17b1a
incl 0x44(%rdi)
cmpb $0x1, 0x9(%rsi)
jne 0x17b23
incl 0x40(%rdi)
cmpb $0x1, 0xa(%rsi)
jne 0x17b2c
incl 0x48(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/JMMackenzie[P]binary_to_jass/bin_to_jass.cpp
// Function: usage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void usage(std::string program) {
  std::cerr << program << " <ds2i_prefix> <docid file> <lexicon file>" 
            << "<max quantized score [256 = 8 bit quant, 512 = 9 bit quant]><q|G|g [QMX, EliasGammaSIMD, EliasGammaSIMDvb]>\n";
  std::cerr << "e.g. " << program << " wsj wsj.documents wsj.terms 256 G\n";
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5a3a7(%rip), %r14     # 0x5dfe8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21a0
leaq 0x555a6(%rip), %rsi     # 0x591f9
movq %rax, %rdi
callq 0x21c0
leaq 0x555c2(%rip), %rsi     # 0x59224
movq %rax, %rdi
callq 0x21c0
leaq 0x55620(%rip), %rsi     # 0x59291
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21a0
leaq 0x5560c(%rip), %rsi     # 0x59297
movq %rax, %rdi
callq 0x21c0
movl $0x1, %edi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/DMLfor[P]TinyWebServer/./ServerHttp.hpp
// Function: WebServer::Server<boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::execution::any_executor<boost::asio::execution::context_as_t<boost::asio::execution_context&>, boost::asio::execution::detail::blocking::never_t<0>, boost::asio::execution::prefer_only<boost::asio::execution::detail::blocking::possibly_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::tracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::untracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::fork_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::continuation_t<0>>>>>::accept()
void accept()
		{
			// 为当前连接创建一个新的 socket
			// Shared_ptr 用于传递临时对象给匿名函数
			// socket 会被推导为 std::shared_ptr<HTTP> 类型
			auto socket = std::make_shared<HTTP>(m_io_service);

			acceptor.async_accept(*socket, [this, socket](const boost::system::error_code & ec)
					{
						// 立即启动并接受一个连接
						accept();
						// 如果出现错误
						if(!ec) process_request_and_respond(socket);
					});
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x68(%rdi), %rcx
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x18(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x11188
movq (%r14), %rdx
movq 0x8(%r14), %rax
movq %rbx, (%r15)
movq %rdx, 0x8(%r15)
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0xafc6
movq 0x2cff8(%rip), %rcx     # 0x37fb0
cmpb $0x0, (%rcx)
je 0xafc2
incl 0x8(%rax)
jmp 0xafc6
lock
incl 0x8(%rax)
movq 0x98(%rbx), %rdi
leaq 0xa0(%rbx), %rsi
addq $0xb8, %rbx
leaq 0x18(%rsp), %r8
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x1125a
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xaff9
callq 0x14ab8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb008
callq 0x14ab8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xb024
callq 0x14ab8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb033
callq 0x14ab8
movq %rbx, %rdi
callq 0x9890
nop
// File: /workspace/github_cpp_makefile_star2_O1/dwkim606[P]IPPBA/main.cpp
// Function: printProgress(double)
void printProgress(double percentage)
{
	int val = (int)(percentage * 100);
	int lpad = (int)(percentage * PBWIDTH);
	int rpad = PBWIDTH - lpad;
	printf("\r%3d%% [%.*s%*s]", val, lpad, PBSTR, rpad, "");
	fflush(stdout);
}

// Assembly:
pushq %rax
movsd 0x1b43(%rip), %xmm1     # 0x4008
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
mulsd 0x1b3b(%rip), %xmm0     # 0x4010
cvttsd2si %xmm0, %edx
movl $0x3c, %r8d
subl %edx, %r8d
leaq 0x1b2f(%rip), %rdi      # 0x4018
leaq 0x1b39(%rip), %rcx      # 0x4029
leaq 0x1b83(%rip), %r9       # 0x407a
xorl %eax, %eax
callq 0x2050
movq 0x3ab3(%rip), %rax      # 0x5fb8
movq (%rax), %rdi
popq %rax
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/dwkim606[P]IPPBA/Scheme.cpp
// Function: Scheme::mskGen(MasterSecretKey&)
void mskGen(MasterSecretKey& msk) {
		int i, j, k;
		for (i = 0; i <N; ++i) {
			for (j = 0; j < K; ++j) {
				msk.S[i * K + j] = (U(GEN)%2);
			}
		}
		for (k = 0; k < M; ++k) msk.U[k] = (U(GEN) >> (SFT));
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x6304(%rip), %r14      # 0x9210
leaq 0x6cc5(%rip), %r15      # 0x9bd8
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2d18
movq (%rbx), %rcx
addq %r12, %rcx
andb $0x1, %al
movb %al, (%rbp,%rcx)
incq %rbp
cmpq $0x239a8, %rbp          # imm = 0x239A8
jne 0x2f18
incq %r13
addq $0x239a8, %r12          # imm = 0x239A8
cmpq $0x785, %r13            # imm = 0x785
jne 0x2f16
xorl %r12d, %r12d
leaq 0x62b5(%rip), %r14      # 0x9210
leaq 0x6c76(%rip), %r15      # 0x9bd8
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2d18
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq $0x2412d, %r12          # imm = 0x2412D
jne 0x2f62
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dwkim606[P]IPPBA/Scheme.cpp
// Function: Scheme::templateGen(unsigned long (&) [147757], MasterSecretKey&, unsigned long (&) [145832])
void templateGen(EncryptedTemplate& encX, MasterSecretKey& msk, Biometric& x) {
		int i, j;
		for (i = 0; i < K; ++i) encX[i] = x[i] + msk.U[i];
		for (i = 0; i < N; ++i) {
			encX[i + K] = msk.U[i + K];
			for (j = 0; j < K; ++j){
				encX[i + K] += (msk.S[i * K + j] * x[j]);
			}
		}
	}

// Assembly:
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
movq (%rax,%rcx,8), %r8
addq (%rdx,%rcx,8), %r8
movq %r8, (%rdi,%rcx,8)
incq %rcx
cmpq $0x239a8, %rcx          # imm = 0x239A8
jne 0x2f99
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
xorl %esi, %esi
movq 0x11cd40(%rcx,%rsi,8), %r8
movq %r8, 0x11cd40(%rdi,%rsi,8)
xorl %r9d, %r9d
movzbl (%rax,%r9), %r10d
imulq (%rdx,%r9,8), %r10
addq %r10, %r8
movq %r8, 0x11cd40(%rdi,%rsi,8)
incq %r9
cmpq $0x239a8, %r9           # imm = 0x239A8
jne 0x2fcd
incq %rsi
addq $0x239a8, %rax          # imm = 0x239A8
cmpq $0x785, %rsi            # imm = 0x785
jne 0x2fba
retq
// File: /workspace/github_cpp_makefile_star2_O1/dwkim606[P]IPPBA/Scheme.cpp
// Function: Scheme::encryptBio(unsigned long (&) [147758], MasterSecretKey&, unsigned long (&) [145832])
void encryptBio(EncryptedBio& encY, MasterSecretKey& msk, Biometric& y) {
		int i, j;
		for (i = K + 1; i < M + 1; ++i) encY[i] = (U(GEN) << (SFT));
		for (i = 0; i < K; ++i) {
			encY[i + 1] = (ZmodQ)(DG(GEN)*pow(2, SFT) + 0.5) + (y[i] << (LOGQ - LOGP + SFT));
			for (j = 0; j < N; ++j) encY[i + 1] -= encY[K + 1 + j] * msk.S[j * K + i];
		}
		encY[0] = (ZmodQ)(DGstar(GEN)*pow(2, SFT) + 0.5);
		for (i = 0; i < M; ++i) encY[0] -= msk.U[i] * encY[i + 1];	
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x239a9, %ebp          # imm = 0x239A9
leaq 0x61ef(%rip), %r12      # 0x9210
leaq 0x6bb0(%rip), %r13      # 0x9bd8
movq %r13, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2d18
movq %rax, (%rbx,%rbp,8)
incq %rbp
cmpq $0x2412e, %rbp          # imm = 0x2412E
jne 0x3028
xorl %eax, %eax
leaq 0x61c1(%rip), %r12      # 0x9210
leaq 0x6b92(%rip), %r13      # 0x9be8
movq %rax, %rbp
movq %r13, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x318e
addsd 0x1121(%rip), %xmm0     # 0x4190
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1115(%rip), %xmm0     # 0x4198
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq (%r15,%rbp,8), %rcx
shlq $0x20, %rcx
addq %rdx, %rcx
leaq 0x1(%rbp), %rax
movq %rcx, 0x8(%rbx,%rbp,8)
addq (%r14), %rbp
movl $0x239a9, %edx          # imm = 0x239A9
movzbl (%rbp), %esi
imulq (%rbx,%rdx,8), %rsi
subq %rsi, %rcx
movq %rcx, (%rbx,%rax,8)
addq $0x239a8, %rbp          # imm = 0x239A8
incq %rdx
cmpq $0x2412e, %rdx          # imm = 0x2412E
jne 0x30aa
cmpq $0x239a8, %rax          # imm = 0x239A8
jne 0x3056
leaq 0x6134(%rip), %rsi      # 0x9210
leaq 0x6b25(%rip), %rdi      # 0x9c08
movq %rdi, %rdx
callq 0x318e
addsd 0x109d(%rip), %xmm0     # 0x4190
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
subsd 0x1095(%rip), %xmm0     # 0x4198
sarq $0x3f, %rdx
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
movq 0x8(%r14), %rcx
movq %rax, (%rbx)
movl $0x1, %edx
movq (%rbx,%rdx,8), %rsi
imulq -0x8(%rcx,%rdx,8), %rsi
subq %rsi, %rax
movq %rax, (%rbx)
incq %rdx
cmpq $0x2412e, %rdx          # imm = 0x2412E
jne 0x311e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dwkim606[P]IPPBA/Scheme.cpp
// Function: Scheme::innerProduct(unsigned long (&) [147757], unsigned long (&) [147758])
int64_t innerProduct(EncryptedTemplate& encX, EncryptedBio& encY) {
		ZmodQ res = encY[0];
		int64_t comp = 1;
		comp <<= (LOGP - 1);
		int64_t result;

		for (int i = 0; i < M; ++i) res += encX[i] * encY[i + 1];
		res += ((ZmodQ)1 << (LOGQ - LOGP - 1 + SFT));
		res >>= (LOGQ - LOGP + SFT);
		result = (int64_t) res;
		if (result >= comp)	result -= 2 * comp;

		return result;
	}

// Assembly:
movq (%rsi), %rcx
xorl %eax, %eax
movq 0x8(%rsi,%rax,8), %rdx
imulq (%rdi,%rax,8), %rdx
leaq 0x1(%rax), %r8
addq %rdx, %rcx
movq %r8, %rax
cmpq $0x2412d, %r8           # imm = 0x2412D
jne 0x314e
subq $-0x80000000, %rcx      # imm = 0x80000000
movq %rcx, %rdx
shrq $0x20, %rdx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
orq %rdx, %rax
testq %rcx, %rcx
cmovnsq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::details::file_descriptor::open()
bool open()
         {
            if (e_read == mode)
            {
               std::ifstream* stream = new std::ifstream(file_name.c_str(),std::ios::binary);

               if (!(*stream))
               {
                  file_name.clear();
                  delete stream;

                  return false;
               }

               stream_ptr = stream;

               return true;
            }
            else if (e_write == mode)
            {
               std::ofstream* stream = new std::ofstream(file_name.c_str(),std::ios::binary);

               if (!(*stream))
               {
                  file_name.clear();
                  delete stream;

                  return false;
               }

               stream_ptr = stream;

               return true;
            }
            else if (e_rdwrt == mode)
            {
               std::fstream* stream = new std::fstream(file_name.c_str(),std::ios::binary);

               if (!(*stream))
               {
                  file_name.clear();
                  delete stream;

                  return false;
               }

               stream_ptr = stream;

               return true;
            }

            return false;
         }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x4, %eax
je 0x19ca99
cmpl $0x2, %eax
je 0x19ca79
cmpl $0x1, %eax
jne 0x19cae6
movl $0x208, %edi            # imm = 0x208
callq 0x11e100
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movl $0x4, %edx
callq 0x11e060
jmp 0x19cab7
movl $0x200, %edi            # imm = 0x200
callq 0x11e100
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movl $0x4, %edx
callq 0x11e1d0
jmp 0x19cab7
movl $0x210, %edi            # imm = 0x210
callq 0x11e100
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movl $0x4, %edx
callq 0x11e1a0
movq (%r14), %rax
movq -0x18(%rax), %rcx
testb $0x5, 0x20(%r14,%rcx)
sete %bpl
je 0x19cae1
movq $0x0, 0x18(%rbx)
movq 0x10(%rbx), %rcx
movb $0x0, (%rcx)
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x19cae8
movq %r14, (%rbx)
jmp 0x19cae8
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movl $0x208, %esi            # imm = 0x208
jmp 0x19cb0b
movq %rax, %rbx
movl $0x210, %esi            # imm = 0x210
jmp 0x19cb0b
movq %rax, %rbx
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdi
callq 0x11e0d0
movq %rbx, %rdi
callq 0x11e3c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::close<double>::operator()(double const&)
inline T operator() (const T& v) exprtk_override
      {
         details::file_descriptor* fd = details::make_handle(v);

         if (!fd->close())
            return T(0);

         delete fd;

         return T(1);
      }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd (%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x19cc20
xorps %xmm0, %xmm0
testb %al, %al
je 0x19cc1a
movq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x19cc05
movq (%rax), %rsi
incq %rsi
callq 0x11e0d0
movl $0x30, %esi
movq %rbx, %rdi
callq 0x11e0d0
movsd 0x149446(%rip), %xmm0   # 0x2e6060
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::details::file_descriptor::close()
bool close()
         {
            switch (mode)
            {
               case e_read  : close<std::ifstream>(stream_ptr);
                              break;

               case e_write : close<std::ofstream>(stream_ptr);
                              break;

               case e_rdwrt : close<std::fstream> (stream_ptr);
                              break;

               default      : return false;
            }

            return true;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x4, %eax
je 0x19cc53
cmpl $0x2, %eax
je 0x19cc46
cmpl $0x1, %eax
jne 0x19cc72
movq (%rbx), %r14
movq %r14, %rdi
callq 0x11e3a0
jmp 0x19cc5e
movq (%rbx), %r14
movq %r14, %rdi
callq 0x11e570
jmp 0x19cc5e
movq (%rbx), %r14
movq %r14, %rdi
callq 0x11e190
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, (%rbx)
movb $0x1, %al
jmp 0x19cc74
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::write<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])());

         switch (ps_index)
         {
            case 0  : {
                         const string_t buffer(parameters[1]);
                         const std::size_t amount = buffer.size();
                         return T(fd->write(buffer, amount) ? 1 : 0);
                      }

            case 1  : {
                         const string_t buffer(parameters[1]);
                         const std::size_t amount =
                                  std::min(buffer.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->write(buffer, amount) ? 1 : 0);
                      }

            case 2  : {
                         const vector_t vec(parameters[1]);
                         const std::size_t amount = vec.size();
                         return T(fd->write(vec, amount) ? 1 : 0);
                      }

            case 3  : {
                         const vector_t vec(parameters[1]);
                         const std::size_t amount =
                                  std::min(vec.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->write(vec, amount) ? 1 : 0);
                      }
         }

         return T(0);
      }

// Assembly:
subq $0x18, %rsp
movq (%rdx), %rax
movq (%rax), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rsi), %rcx
cmpq $0x3, %rcx
ja 0x19cdc8
movq 0x8(%rsp), %rdi
leaq 0x14a42b(%rip), %rdx    # 0x2e7108
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x20(%rax), %rdx
jmp 0x19cdb2
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x20(%rax), %rdx
jmp 0x19cd63
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x30(%rax), %rcx
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %rcx
movq 0x20(%rax), %rax
movq %rcx, %r8
subsd 0x14936b(%rip), %xmm0   # 0x2e60b8
sarq $0x3f, %r8
cvttsd2si %xmm0, %rdx
andq %r8, %rdx
orq %rcx, %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
xorl %ecx, %ecx
callq 0x19cdfe
jmp 0x19cdb9
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x30(%rax), %rcx
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %rcx
movq 0x20(%rax), %rax
movq %rcx, %r8
subsd 0x14931c(%rip), %xmm0   # 0x2e60b8
sarq $0x3f, %r8
cvttsd2si %xmm0, %rdx
andq %r8, %rdx
orq %rcx, %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
xorl %ecx, %ecx
callq 0x19cdce
movzbl %al, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
addq $0x18, %rsp
retq
xorpd %xmm0, %xmm0
jmp 0x19cdc3
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: bool exprtk::rtl::io::file::details::file_descriptor::write<exprtk::type_store<double>::type_view<char>>(exprtk::type_store<double>::type_view<char> const&, unsigned long, unsigned long)
bool write(const View& view, const std::size_t amount, const std::size_t offset = 0)
         {
            switch (mode)
            {
               case e_write : reinterpret_cast<std::ofstream*>(stream_ptr)->
                                 write(reinterpret_cast<char_cptr>(view.begin() + offset), amount * sizeof(typename View::value_t));
                              break;

               case e_rdwrt : reinterpret_cast<std::fstream*>(stream_ptr)->
                                 write(reinterpret_cast<char_cptr>(view.begin() + offset) , amount * sizeof(typename View::value_t));
                              break;

               default      : return false;
            }

            return true;
         }

// Assembly:
movl 0x8(%rdi), %eax
cmpl $0x4, %eax
je 0x19cde0
cmpl $0x2, %eax
jne 0x19cdfb
movq (%rdi), %rdi
jmp 0x19cde7
movq (%rdi), %rdi
addq $0x10, %rdi
pushq %rax
addq 0x8(%rsi), %rcx
movq %rcx, %rsi
callq 0x11e2d0
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::read<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])());

         switch (ps_index)
         {
            case 0  : {
                         string_t buffer(parameters[1]);
                         const std::size_t amount = buffer.size();
                         return T(fd->read(buffer,amount) ? 1 : 0);
                      }

            case 1  : {
                         string_t buffer(parameters[1]);
                         const std::size_t amount =
                                  std::min(buffer.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->read(buffer,amount) ? 1 : 0);
                      }

            case 2  : {
                         vector_t vec(parameters[1]);
                         const std::size_t amount = vec.size();
                         return T(fd->read(vec,amount) ? 1 : 0);
                      }

            case 3  : {
                         vector_t vec(parameters[1]);
                         const std::size_t amount =
                                  std::min(vec.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->read(vec,amount) ? 1 : 0);
                      }
         }

         return T(0);
      }

// Assembly:
subq $0x18, %rsp
movq (%rdx), %rax
movq (%rax), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rsi), %rcx
cmpq $0x3, %rcx
ja 0x19cf82
movq 0x8(%rsp), %rdi
leaq 0x14a281(%rip), %rdx    # 0x2e7118
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x20(%rax), %rdx
jmp 0x19cf6c
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x20(%rax), %rdx
jmp 0x19cf1d
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x30(%rax), %rcx
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %rcx
movq 0x20(%rax), %rax
movq %rcx, %r8
subsd 0x1491b1(%rip), %xmm0   # 0x2e60b8
sarq $0x3f, %r8
cvttsd2si %xmm0, %rdx
andq %r8, %rdx
orq %rcx, %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
xorl %ecx, %ecx
callq 0x19cfb0
jmp 0x19cf73
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x30(%rax), %rcx
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %rcx
movq 0x20(%rax), %rax
movq %rcx, %r8
subsd 0x149162(%rip), %xmm0   # 0x2e60b8
sarq $0x3f, %r8
cvttsd2si %xmm0, %rdx
andq %r8, %rdx
orq %rcx, %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
xorl %ecx, %ecx
callq 0x19cf88
movzbl %al, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
addq $0x18, %rsp
retq
xorpd %xmm0, %xmm0
jmp 0x19cf7d
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::trim_whitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string trim_whitespace(std::string s)
   {
      static const std::string whitespace(" \n\r\t\b\v\f");

      if (!s.empty())
      {
         s.erase(0,s.find_first_not_of(whitespace));

         if (!s.empty())
         {
            std::size_t index = s.find_last_not_of(whitespace);

            if (std::string::npos != index)
               s.erase(index + 1);
            else
               s.clear();
         }
      }

      return s;
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movb 0x1840ca(%rip), %al     # 0x466fa8
testb %al, %al
je 0x2e2fac
cmpq $0x0, 0x8(%r14)
je 0x2e2f64
movq 0x184094(%rip), %rsi    # 0x466f88
movq 0x184095(%rip), %rcx    # 0x466f90
movq %r14, %rdi
xorl %edx, %edx
callq 0x11e480
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x11e410
cmpq $0x0, 0x8(%r14)
je 0x2e2f64
movq 0x184068(%rip), %rsi    # 0x466f88
movq 0x184069(%rip), %rcx    # 0x466f90
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x11e150
cmpq $-0x1, %rax
je 0x2e2f56
leaq 0x1(%rax), %rdx
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
jbe 0x2e3013
movq %rdx, 0x8(%r14)
addq (%r14), %rdx
jmp 0x2e2f61
movq $0x0, 0x8(%r14)
movq (%r14), %rdx
movb $0x0, (%rdx)
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x2e2f83
movq %rdx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x2e2f89
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x183ff5(%rip), %rdi    # 0x466fa8
callq 0x11e200
testl %eax, %eax
je 0x2e2ee6
leaq 0x183fd1(%rip), %rax    # 0x466f98
movq %rax, 0x183fba(%rip)    # 0x466f88
leaq 0x183fb3(%rip), %rdi    # 0x466f88
leaq 0xc9f5(%rip), %rsi      # 0x2ef9d1
leaq 0xc9f5(%rip), %rdx      # 0x2ef9d8
callq 0x121a7e
movq 0x180ff1(%rip), %rdi    # 0x463fe0
leaq 0x183f92(%rip), %rsi    # 0x466f88
leaq 0x181393(%rip), %rdx    # 0x464390
callq 0x11e520
leaq 0x183f9f(%rip), %rdi    # 0x466fa8
callq 0x11e350
jmp 0x2e2ee6
leaq 0x806f(%rip), %rdi      # 0x2eb089
leaq 0xc19f(%rip), %rsi      # 0x2ef1c0
xorl %eax, %eax
callq 0x11e050
movq %rax, %rbx
leaq 0x183f76(%rip), %rdi    # 0x466fa8
callq 0x11e280
movq %rbx, %rdi
callq 0x11e3c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_disable_arithmetic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_disable_arithmetic(const std::string& arithmetic)
   {
      typename std::map<std::string,typename settings_store_t::settings_arithmetic_opr>::iterator itr;

      if (arith_opr_.end() != (itr = arith_opr_.find(arithmetic)))
      {
         parser_.settings()
            .disable_arithmetic_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1fc0, %rdi           # imm = 0x1FC0
leaq 0x1fc8(%rbx), %r14
callq 0x2e3fd4
cmpq %rax, %r14
je 0x2e346d
movl 0x40(%rax), %eax
decl %eax
cmpl $0x5, %eax
ja 0x2e346d
addq $0x190, %rbx            # imm = 0x190
movl %eax, %eax
shlq $0x5, %rax
leaq 0x1827e5(%rip), %rsi    # 0x465c40
addq %rax, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x132c3e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_disable_assignment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_disable_assignment(const std::string& assignment)
   {
      typename std::map<std::string,typename settings_store_t::settings_assignment_opr>::iterator itr;

      if (assign_opr_.end() != (itr = assign_opr_.find(assignment)))
      {
         parser_.settings()
            .disable_assignment_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1ff0, %rdi           # imm = 0x1FF0
leaq 0x1ff8(%rbx), %r14
callq 0x2e401a
cmpq %rax, %r14
je 0x2e34c5
movl 0x40(%rax), %eax
decl %eax
cmpl $0x5, %eax
ja 0x2e34c5
addq $0x1c0, %rbx            # imm = 0x1C0
movl %eax, %eax
shlq $0x5, %rax
leaq 0x18284d(%rip), %rsi    # 0x465d00
addq %rax, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x132c3e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_disable_inequality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_disable_inequality(const std::string& inequality)
   {
      typename std::map<std::string,typename settings_store_t::settings_inequality_opr>::iterator itr;

      if (inequality_opr_.end() != (itr = inequality_opr_.find(inequality)))
      {
         parser_.settings()
            .disable_inequality_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x2020, %rdi           # imm = 0x2020
leaq 0x2028(%rbx), %r14
callq 0x2e4060
cmpq %rax, %r14
je 0x2e351d
movl 0x40(%rax), %eax
decl %eax
cmpl $0x7, %eax
ja 0x2e351d
addq $0x1f0, %rbx            # imm = 0x1F0
movl %eax, %eax
shlq $0x5, %rax
leaq 0x1828b5(%rip), %rsi    # 0x465dc0
addq %rax, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x132c3e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_enable_arithmetic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_enable_arithmetic(const std::string& arithmetic)
   {
      typename std::map<std::string,typename settings_store_t::settings_arithmetic_opr>::iterator itr;

      if (arith_opr_.end() != (itr = arith_opr_.find(arithmetic)))
      {
         parser_.settings()
            .enable_arithmetic_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1fc0, %rdi           # imm = 0x1FC0
leaq 0x1fc8(%rbx), %r14
callq 0x2e3fd4
cmpq %rax, %r14
je 0x2e355e
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e40a6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_enable_assignment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_enable_assignment(const std::string& assignment)
   {
      typename std::map<std::string,typename settings_store_t::settings_assignment_opr>::iterator itr;

      if (assign_opr_.end() != (itr = assign_opr_.find(assignment)))
      {
         parser_.settings()
            .enable_assignment_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1ff0, %rdi           # imm = 0x1FF0
leaq 0x1ff8(%rbx), %r14
callq 0x2e401a
cmpq %rax, %r14
je 0x2e359e
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e4130
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_enable_inequality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_enable_inequality(const std::string& inequality)
   {
      typename std::map<std::string,typename settings_store_t::settings_inequality_opr>::iterator itr;

      if (inequality_opr_.end() != (itr = inequality_opr_.find(inequality)))
      {
         parser_.settings()
            .enable_inequality_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x2020, %rdi           # imm = 0x2020
leaq 0x2028(%rbx), %r14
callq 0x2e4060
cmpq %rax, %r14
je 0x2e35de
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e4180
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::enable_arithmetic_operation(exprtk::parser<double>::settings_store::settings_arithmetic_opr)
settings_store& enable_arithmetic_operation(const settings_arithmetic_opr arithmetic)
         {
            if (
                 (e_arith_unknown != arithmetic) &&
                 (static_cast<std::size_t>(arithmetic) < (details::arithmetic_ops_list_size + 1))
               )
            {
               const des_itr_t itr = disabled_arithmetic_set_.find(details::arithmetic_ops_list[arithmetic - 1]);

               if (disabled_arithmetic_set_.end() != itr)
               {
                  disabled_arithmetic_set_.erase(itr);
               }
            }

            return (*this);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %esi
cmpl $0x5, %esi
ja 0x2e40ea
leaq 0xa0(%rbx), %r14
movl %esi, %eax
shlq $0x5, %rax
leaq 0x181b78(%rip), %rsi    # 0x465c40
addq %rax, %rsi
movq %r14, %rdi
callq 0x12f108
leaq 0xa8(%rbx), %rcx
cmpq %rax, %rcx
je 0x2e40ea
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e40f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::enable_assignment_operation(exprtk::parser<double>::settings_store::settings_assignment_opr)
settings_store& enable_assignment_operation(const settings_assignment_opr assignment)
         {
            if (
                 (e_assign_unknown != assignment) &&
                 (static_cast<std::size_t>(assignment) < (details::assignment_ops_list_size + 1))
               )
            {
               const des_itr_t itr = disabled_assignment_set_.find(details::assignment_ops_list[assignment - 1]);

               if (disabled_assignment_set_.end() != itr)
               {
                  disabled_assignment_set_.erase(itr);
               }
            }

            return (*this);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %esi
cmpl $0x5, %esi
ja 0x2e4174
leaq 0xd0(%rbx), %r14
movl %esi, %eax
shlq $0x5, %rax
leaq 0x181bae(%rip), %rsi    # 0x465d00
addq %rax, %rsi
movq %r14, %rdi
callq 0x12f108
leaq 0xd8(%rbx), %rcx
cmpq %rax, %rcx
je 0x2e4174
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e40f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::enable_inequality_operation(exprtk::parser<double>::settings_store::settings_inequality_opr)
settings_store& enable_inequality_operation(const settings_inequality_opr inequality)
         {
            if (
                 (e_ineq_unknown != inequality) &&
                 (static_cast<std::size_t>(inequality) < (details::inequality_ops_list_size + 1))
               )
            {
               const des_itr_t itr = disabled_inequality_set_.find(details::inequality_ops_list[inequality - 1]);

               if (disabled_inequality_set_.end() != itr)
               {
                  disabled_inequality_set_.erase(itr);
               }
            }

            return (*this);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %esi
cmpl $0x7, %esi
ja 0x2e41c4
leaq 0x100(%rbx), %r14
movl %esi, %eax
shlq $0x5, %rax
leaq 0x181c1e(%rip), %rsi    # 0x465dc0
addq %rax, %rsi
movq %r14, %rdi
callq 0x12f108
leaq 0x108(%rbx), %rcx
cmpq %rax, %rcx
je 0x2e41c4
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e40f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop