LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gauravtewari[P]netlist/netlist.cpp
// Function: trim(char*)
char *trim(char *token){
		char *last;
		
		/* Remove leading spaces from token */
		while(isspace(*token)) token++;
		if(*token == 0) return token;	/* Check if its all spaces */
			
		/* Remove trailing spaces from token */
		last = token + strlen(token) - 1;				/* Got to last non null character of string */
		while(last > token && isspace(*last)) last--;		/* Check all the characters that are space by going back up */
		*(last+1) = '\0';									/* Null terminate the token */
		return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2060
cmpl $0x0, %eax
je 0x549b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x547c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x54b1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x551f
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2120
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x21(%rbp)
jbe 0x54f8
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x2060
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5501
jmp 0x550f
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x54d4
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: gauravtewari[P]netlist/netlist.cpp
// Function: circuit::add_output_edge(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int circuit::add_output_edge(string &str){
	if(str.empty())
		return -1;
	u32 gate_id, net_id;
	gate_id = add_gate(get_gate_type("OUTPUT"));
	gate_list[gate_id].fan_in = 1;

	net_id = add_net(OUTPUT_NET, str);
	if(net_list[net_id].type == INPUT_NET){
		net_list[net_id].type = IO_NET;
		net_type[INPUT_NET]--;
		net_type[IO_NET]++;
	}
	net_list[net_id].gates.push_back(gate_id);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x23a0
testb $0x1, %al
jne 0x57d7
jmp 0x57e3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x591e
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x23d0
movq -0x68(%rbp), %rdx
leaq 0x589a(%rip), %rsi      # 0xb095
leaq -0x40(%rbp), %rdi
callq 0x34f0
jmp 0x5806
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5c30
movl %eax, -0x6c(%rbp)
jmp 0x5818
movl -0x6c(%rbp), %esi
movq -0x60(%rbp), %rdi
callq 0x5b50
movl %eax, -0x70(%rbp)
jmp 0x5829
movl -0x70(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2170
leaq -0x41(%rbp), %rdi
callq 0x2280
movq -0x60(%rbp), %rdi
addq $0x90, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x6890
movq -0x60(%rbp), %rdi
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x5930
movq -0x60(%rbp), %rdi
movl %eax, -0x20(%rbp)
addq $0xa8, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x67c0
cmpl $0x0, 0x8(%rax)
jne 0x58f2
movq -0x60(%rbp), %rdi
addq $0xa8, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x67c0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl $0x2, 0x8(%rcx)
movl 0x2c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rax)
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
jmp 0x58f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x58e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2170
leaq -0x41(%rbp), %rdi
callq 0x2280
jmp 0x5927
movq -0x60(%rbp), %rdi
addq $0xa8, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x67c0
movq %rax, %rdi
addq $0x10, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x6900
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x23c0
// File: gauravtewari[P]netlist/netlist.cpp
// Function: circuit::add_net(net_t, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
u32 circuit::add_net(net_t type, string &tag){
	struct net temp;

	/* Check if the edge already exists */
	if(edge_map.find(tag) == edge_map.end()){
		/* Allocate a new net entry */
		struct net temp;
		edge_map[tag]=num_nets;
		temp.id = num_nets;
		temp.weight = 0;
		temp.type = type;
		temp.gates = list<u32>();
		net_list.push_back(temp);
		net_type[temp.type]++;
		num_nets++;
		return temp.id;
	}
	else
	 return edge_map[tag];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6940
movq -0xc8(%rbp), %rdi
addq $0xc0, %rdi
movq -0x20(%rbp), %rsi
callq 0x69d0
movq %rax, -0xc0(%rbp)
jmp 0x597a
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0xc0, %rdi
callq 0x6a00
movq %rax, -0x68(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x69a0
testb $0x1, %al
jne 0x59b2
jmp 0x5ae5
leaq -0x90(%rbp), %rdi
callq 0x6940
jmp 0x59c0
movq -0xc8(%rbp), %rdi
movl 0x4(%rdi), %eax
movl %eax, -0xd4(%rbp)
addq $0xc0, %rdi
movq -0x20(%rbp), %rsi
callq 0x6a30
movq %rax, -0xd0(%rbp)
jmp 0x59e9
movq -0xc8(%rbp), %rax
movq -0xd0(%rbp), %rcx
movl -0xd4(%rbp), %edx
movl %edx, (%rcx)
movl 0x4(%rax), %eax
movl %eax, -0x90(%rbp)
movl $0x0, -0x8c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x88(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
movq $0x0, -0xa0(%rbp)
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x6b10
movq -0xe0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x6b30
movq -0xe0(%rbp), %rdi
callq 0x42c0
movq -0xc8(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x90(%rbp), %rsi
callq 0x6b60
jmp 0x5a7b
movq -0xc8(%rbp), %rax
movl -0x88(%rbp), %ecx
movl 0x2c(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x2c(%rax,%rcx,4)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x90(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0xb4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x42a0
jmp 0x5b1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5b30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x42a0
jmp 0x5b30
movq -0xc8(%rbp), %rdi
addq $0xc0, %rdi
movq -0x20(%rbp), %rsi
callq 0x6a30
movq %rax, -0xe8(%rbp)
jmp 0x5b05
movq -0xe8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0xb4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x42a0
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x42a0
movq -0x58(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
// File: gauravtewari[P]netlist/netlist.cpp
// Function: circuit::add_gate(unsigned int)
u32 circuit::add_gate(u32 type){
	/* we have to add a new gate to the gates adjacency list */
	struct gate temp;
	temp.id = num_gates;
	temp.type = type;
	temp.fan_out = 0;
	temp.fan_in = 0;
	temp.nets = list<u32>();
	gate_list.push_back(temp);
	
	num_gates++;
	gate_type[temp.type]++;
	return temp.id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x6bd0
movq -0x70(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6b10
movq -0x78(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x6b30
movq -0x78(%rbp), %rdi
callq 0x42c0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x90, %rdi
callq 0x6c40
jmp 0x5bdc
movq -0x70(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %ecx
movl 0x8(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x8(%rax,%rcx,4)
movl -0x38(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4740
movl -0x7c(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4740
movq -0x58(%rbp), %rdi
callq 0x23c0
nop
// File: gauravtewari[P]netlist/netlist.cpp
// Function: circuit::get_gate_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
u32 circuit::get_gate_type(string str){
	u32 size = (u32)gate_t.size();
	if(gate_t.find(str) == gate_t.end())
		gate_t[str]=size;
	return gate_t[str];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0xf0, %rdi
callq 0x35a0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movl %eax, -0x14(%rbp)
addq $0xf0, %rdi
callq 0x6e90
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xf0, %rdi
callq 0x6ec0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6e60
testb $0x1, %al
jne 0x5c9a
jmp 0x5cb9
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
addq $0xf0, %rdi
callq 0x6ef0
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0xf0, %rdi
callq 0x6ef0
movl (%rax), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gauravtewari[P]netlist/netlist.cpp
// Function: circuit::add_gate_to_net(unsigned int, unsigned int)
int circuit::add_gate_to_net(u32 net_id, u32 gate_id){
	
	/* We assume that gate_id and net_id are valid and the corresponding entries exist */
	if(!net_list[net_id].gates.empty()){
		net_type[net_list[net_id].type]--;
		net_list[net_id].type = HYPEREDGE;
		net_type[net_list[net_id].type]++;
	}
	
	net_list[net_id].gates.push_back(gate_id);
	/* We defer the fan_out updation till later */
	/* Fan in is updated here */
	gate_list[gate_id].fan_in ++;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0xa8, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x67c0
movq %rax, %rdi
addq $0x10, %rdi
callq 0x68e0
testb $0x1, %al
jne 0x5dc4
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x67c0
movq -0x18(%rbp), %rdi
movl 0x8(%rax), %eax
movl 0x2c(%rdi,%rax,4), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rdi,%rax,4)
addq $0xa8, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x67c0
movq -0x18(%rbp), %rdi
movl $0x3, 0x8(%rax)
addq $0xa8, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x67c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl 0x8(%rcx), %ecx
movl 0x2c(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x2c(%rax,%rcx,4)
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x67c0
movq %rax, %rdi
addq $0x10, %rdi
leaq -0x10(%rbp), %rsi
callq 0x6900
movq -0x18(%rbp), %rdi
addq $0x90, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x6890
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: gauravtewari[P]netlist/netlist.cpp
// Function: circuit::update_fan_out()
int circuit::update_fan_out(){
	
	/* for each gate */
	for(vector<struct gate>::iterator i = gate_list.begin(); i != gate_list.end(); i++){
		/* Iterate over the edges that this gate drives, for nets that don't have any out edges (output gate) this loop wont run */
		for(list<u32>::const_iterator j = i->nets.begin(); j != i->nets.end(); j++){
			/* add the number of gates each edge drives to fan out */
			i->fan_out += net_list[*j].gates.size();
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x90, %rdi
callq 0x33b0
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rdi
addq $0x90, %rdi
callq 0x3460
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6cb0
testb $0x1, %al
jne 0x63fe
jmp 0x64d1
leaq -0x10(%rbp), %rdi
callq 0x6cf0
movq %rax, %rdi
addq $0x10, %rdi
callq 0x6810
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6840
leaq -0x10(%rbp), %rdi
callq 0x6cf0
movq %rax, %rdi
addq $0x10, %rdi
callq 0x6860
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6840
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6760
testb $0x1, %al
jne 0x645d
jmp 0x64bb
movq -0x50(%rbp), %rax
addq $0xa8, %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x67e0
movq -0x60(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x67c0
movq %rax, %rdi
addq $0x10, %rdi
callq 0x6d10
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6cf0
movq -0x58(%rbp), %rdx
movl 0xc(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0xc(%rax)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x68b0
movq %rax, -0x40(%rbp)
jmp 0x6424
jmp 0x64bd
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6d40
movq %rax, -0x48(%rbp)
jmp 0x63d4
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/square.cc
// Function: main
int main()
{
	vector<int> v{1,2,3,4,5,6,7,8,9};
	for (auto &i : v) // for each element in v (note: i is a reference)
		i *= i;           // square the element value
	for (auto i : v)      // for each element in v
		cout << i << " "; // print the element
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movups 0xdab(%rip), %xmm0      # 0x2014
movaps %xmm0, -0x50(%rbp)
movups 0xd90(%rip), %xmm0      # 0x2004
movaps %xmm0, -0x60(%rbp)
movl $0x9, -0x40(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x9, -0x28(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x1450
movq -0xc0(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x1470
jmp 0x12b9
leaq -0x61(%rbp), %rdi
callq 0x14f0
leaq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x1510
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
callq 0x1540
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1570
testb $0x1, %al
jne 0x1303
jmp 0x1353
leaq -0x88(%rbp), %rdi
callq 0x15b0
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movl (%rax), %ecx
movq -0x98(%rbp), %rax
imull (%rax), %ecx
movl %ecx, (%rax)
leaq -0x88(%rbp), %rdi
callq 0x15d0
jmp 0x12ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x14f0
jmp 0x1439
leaq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x1510
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x1540
movq %rax, -0xb0(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1570
testb $0x1, %al
jne 0x139d
jmp 0x1408
leaq -0xa8(%rbp), %rdi
callq 0x15b0
movl (%rax), %eax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %esi
movq 0x2c1a(%rip), %rdi      # 0x3fd8
callq 0x10f0
movq %rax, -0xc8(%rbp)
jmp 0x13cc
movq -0xc8(%rbp), %rdi
leaq 0xc4e(%rip), %rsi       # 0x2028
callq 0x1090
jmp 0x13e1
jmp 0x13e3
leaq -0xa8(%rbp), %rdi
callq 0x15d0
jmp 0x1384
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15f0
jmp 0x1439
movq 0x2bc9(%rip), %rdi      # 0x3fd8
movq 0x2bb2(%rip), %rsi      # 0x3fc8
callq 0x10c0
jmp 0x141d
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15f0
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1100
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH14_OverloadedOperationsAndConversions/examples/readStr.cc
// Function: main
int main()
{
	vector<string> vs;
	ReadLine rl(cin);    // object that read lines from cin
	string s;
	while (rl(s))        // store what rl reads into s
		vs.push_back(s);

	cout << "read : " << vs.size() << " elements" << endl;
	PrintString printer;   // uses the defaults; prints to cout
	printer(s);            // prints s followed by a space on cout

	PrintString errors(cerr, '\n');
	errors(s);             // prints s followed by a newline on cerr

	cerr << "for_each printing to cerr" << endl;
	for_each(vs.begin(), vs.end(), PrintString(cerr, '\n'));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2540
movq 0x3cd6(%rip), %rsi      # 0x5fd8
leaq -0x28(%rbp), %rdi
callq 0x2560
jmp 0x230d
leaq -0x58(%rbp), %rdi
callq 0x2150
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2580
movq %rax, -0xb0(%rbp)
jmp 0x232c
movq -0xb0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2140
movb %al, -0xb1(%rbp)
jmp 0x234a
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x2356
jmp 0x2392
leaq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x25b0
jmp 0x2365
jmp 0x2316
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2522
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x20b0
jmp 0x2522
movq 0x3c2f(%rip), %rdi      # 0x5fc8
leaq 0x1c64(%rip), %rsi      # 0x4004
callq 0x20f0
movq %rax, -0xc0(%rbp)
jmp 0x23ae
leaq -0x20(%rbp), %rdi
callq 0x2620
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x2040
movq %rax, -0xc8(%rbp)
jmp 0x23cf
movq -0xc8(%rbp), %rdi
leaq 0x1c2f(%rip), %rsi      # 0x400c
callq 0x20f0
movq %rax, -0xd0(%rbp)
jmp 0x23eb
movq -0xd0(%rbp), %rdi
movq 0x3bbf(%rip), %rsi      # 0x5fb8
callq 0x2120
jmp 0x2400
movq 0x3bc1(%rip), %rsi      # 0x5fc8
leaq -0x68(%rbp), %rdi
movl $0x20, %edx
callq 0x2640
jmp 0x2417
leaq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2670
jmp 0x2426
movq 0x3bc3(%rip), %rsi      # 0x5ff0
leaq -0x78(%rbp), %rdi
movl $0xa, %edx
callq 0x2640
jmp 0x243d
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2670
jmp 0x244c
movq 0x3b9d(%rip), %rdi      # 0x5ff0
leaq 0x1bbc(%rip), %rsi      # 0x4016
callq 0x20f0
movq %rax, -0xd8(%rbp)
jmp 0x2468
movq -0xd8(%rbp), %rdi
movq 0x3b42(%rip), %rsi      # 0x5fb8
callq 0x2120
jmp 0x247d
leaq -0x20(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x2720
movq -0xe0(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x2750
movq %rax, -0x88(%rbp)
movq 0x3b45(%rip), %rsi      # 0x5ff0
leaq -0x98(%rbp), %rdi
movl $0xa, %edx
callq 0x2640
jmp 0x24be
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x98(%rbp), %rdx
movl -0x90(%rbp), %ecx
callq 0x26b0
movb %dl, -0xe9(%rbp)
movq %rax, -0xe8(%rbp)
jmp 0x24ea
movb -0xe9(%rbp), %al
movq -0xe8(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movb %al, -0xa0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x20b0
leaq -0x20(%rbp), %rdi
callq 0x2780
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x2780
movq -0x30(%rbp), %rdi
callq 0x2190
nopw %cs:(%rax,%rax)
nop
// File: tomfunkhouser[P]gaps/apps/mshsegment/mshsegment.cpp
// Function: main
int 
main(int argc, char **argv)
{
  // Check number of arguments
  if (!ParseArgs(argc, argv)) exit(1);

  // Read input mesh
  R3Mesh *mesh = ReadMesh(input_mesh_name);
  if (!mesh) exit(-1);

  // Create segmentation
  R3Segmentation *segmentation = CreateSegmentation(mesh);
  if (!segmentation) exit(-1);

  // Update mesh
  if (!UpdateMesh(mesh, segmentation)) return 0;
  
  // Refine boundaries
  if (refine_mesh_boundaries) {
    if (!RefineBoundaries(mesh)) exit(-1);
  }

  // Write mesh
  if (!WriteMesh(mesh, output_mesh_name)) exit(-1);

  // Write segments to json file
  if (!WriteJson(mesh, output_json_name)) exit(-1);

  // Write segments to ascii file
  if (!WriteAscii(segmentation, output_ascii_name)) exit(-1);

  // Delete mesh
  delete mesh;
  
  // 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 0x10170
cmpl $0x0, %eax
jne 0x10052
movl $0x1, %edi
callq 0xd4e0
movq 0xc1c4f(%rip), %rdi     # 0xd1ca8
callq 0x10840
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x10075
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd4e0
movq 0x10(%rsp), %rdi
callq 0x10a30
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x10096
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd4e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x10b80
cmpl $0x0, %eax
jne 0x100b7
movl $0x0, 0x24(%rsp)
jmp 0x1015c
cmpl $0x0, 0xc1322(%rip)     # 0xd13e0
je 0x100db
movq 0x10(%rsp), %rdi
callq 0x10cc0
cmpl $0x0, %eax
jne 0x100d9
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd4e0
jmp 0x100db
movq 0x10(%rsp), %rdi
movq 0xc1bc9(%rip), %rsi     # 0xd1cb0
callq 0x11170
cmpl $0x0, %eax
jne 0x100fb
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd4e0
movq 0x10(%rsp), %rdi
movq 0xc1bb1(%rip), %rsi     # 0xd1cb8
callq 0x113c0
cmpl $0x0, %eax
jne 0x1011b
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd4e0
movq 0x8(%rsp), %rdi
movq 0xc1b99(%rip), %rsi     # 0xd1cc0
callq 0x11660
cmpl $0x0, %eax
jne 0x1013b
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd4e0
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x10154
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/mshsegment/mshsegment.cpp
// Function: CreateSegmentation(gaps::R3Mesh*)
static R3Segmentation *
CreateSegmentation(R3Mesh *mesh)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate segmentation
  R3Segmentation *segmentation = new R3Segmentation(options);
  if (!segmentation) {
    RNFail("Unable to allocation segmentation\n");
    return NULL;
  }

  // Create points
  if (!CreatePoints(mesh, segmentation)) return NULL;

  // Create clusters
  if (!segmentation->CreateClusters(R3_SEGMENTATION_PLANE_PRIMITIVE_TYPE)) return NULL;

  // Print statistics
  if (print_verbose) {
    printf("Created segmentation ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Segments = %d\n", segmentation->clusters.NEntries());
    fflush(stdout);
  }

  // Return segmentation
  return segmentation;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xa5c50
movq (%rsp), %rdi
callq 0x12040
movl $0xe0, %edi
callq 0xd3d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xc115c(%rip), %rsi     # 0xd1bc8
callq 0x19a20
jmp 0x10a73
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x10ac3
leaq 0x9a7dd(%rip), %rdi     # 0xab269
movb $0x0, %al
callq 0xa9e70
movq $0x0, 0x40(%rsp)
jmp 0x10b6a
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0xe0, %esi
callq 0xd3e0
jmp 0x10b74
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11700
cmpl $0x0, %eax
jne 0x10ae5
movq $0x0, 0x40(%rsp)
jmp 0x10b6a
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x1d4d0
cmpl $0x0, %eax
jne 0x10b04
movq $0x0, 0x40(%rsp)
jmp 0x10b6a
cmpl $0x0, 0xc11bd(%rip)     # 0xd1cc8
je 0x10b60
leaq 0x9a778(%rip), %rdi     # 0xab28c
movb $0x0, %al
callq 0xd070
leaq 0x28(%rsp), %rdi
callq 0xa5d10
leaq 0x9a6f3(%rip), %rdi     # 0xab21f
movb $0x1, %al
callq 0xd070
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0x12150
movl %eax, %esi
leaq 0x9a75c(%rip), %rdi     # 0xab2a6
movb $0x0, %al
callq 0xd070
movq 0xc0448(%rip), %rax     # 0xd0fa0
movq (%rax), %rdi
callq 0xd4b0
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xd690
nop
// File: tomfunkhouser[P]gaps/apps/mshsegment/mshsegment.cpp
// Function: UpdateMesh(gaps::R3Mesh*, gaps::R3Segmentation*)
static int 
UpdateMesh(R3Mesh *mesh, R3Segmentation *segmentation)
{
  // Clear mesh info
  for (int i = 0; i < mesh->NFaces(); i++) {
    R3MeshFace *face = mesh->Face(i);
    mesh->SetFaceSegment(face, -1);
  }    

  // Update mesh info
  for (int i = 0; i < segmentation->clusters.NEntries(); i++) {
    R3SegmentationCluster *cluster = segmentation->clusters.Kth(i);
    for (int j = 0; j < cluster->points.NEntries(); j++) {
      R3SegmentationPoint *point = cluster->points.Kth(j);
      R3MeshFace *face = mesh->Face(point->data_index);
      mesh->SetFaceSegment(face, i);
    }
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %rdi
callq 0x12060
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x10be6
movq 0x50(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x12080
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x120f0
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x10b96
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
callq 0x12150
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x10cb4
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
movl 0x34(%rsp), %esi
callq 0x13330
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x12150
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x10ca2
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
movl 0x24(%rsp), %esi
callq 0x125b0
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0xd4(%rax), %esi
callq 0x12080
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x120f0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x10c31
jmp 0x10ca4
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x10bee
movl $0x1, %eax
addq $0x58, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/apps/mshsegment/mshsegment.cpp
// Function: WriteAscii(gaps::R3Segmentation*, char const*)
static int
WriteAscii(R3Segmentation *segmentation, const char *filename)
{
  // Check filename
  if (!filename) return 1;

  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Write segmentation
  if (!segmentation->WriteFile(filename)) return 0;

  // Print statistics
  if (print_verbose) {
    printf("Wrote segments to %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x11680
movl $0x1, 0x24(%rsp)
jmp 0x116f7
movq %rsp, %rdi
callq 0xa5c50
movq %rsp, %rdi
callq 0x12040
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1dd80
cmpl $0x0, %eax
jne 0x116ae
movl $0x0, 0x24(%rsp)
jmp 0x116f7
cmpl $0x0, 0xc0613(%rip)     # 0xd1cc8
je 0x116ef
movq 0x10(%rsp), %rsi
leaq 0x99cde(%rip), %rdi     # 0xab3a1
movb $0x0, %al
callq 0xd070
movq %rsp, %rdi
callq 0xa5d10
leaq 0x99b46(%rip), %rdi     # 0xab21f
movb $0x1, %al
callq 0xd070
movq 0xbf8b9(%rip), %rax     # 0xd0fa0
movq (%rax), %rdi
callq 0xd4b0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: hexdigit_value(char)
int hexdigit_value(char c)
{
	int nibble = -1;
	if (('0'<=c) && (c<='9'))
	{
		nibble = c-'0';
	}
	if (('a'<=c) && (c<='f'))
	{
		nibble = c-'a' + 10;
	}
	if (('A'<=c) && (c<='F'))
	{
		nibble = c-'A' + 10;
	}
	return nibble;
}

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
movl $0xffffffff, -0x8(%rsp) # imm = 0xFFFFFFFF
movsbl -0x1(%rsp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x23d3
movsbl -0x1(%rsp), %eax
cmpl $0x39, %eax
jg 0x23d3
movsbl -0x1(%rsp), %eax
subl $0x30, %eax
movl %eax, -0x8(%rsp)
movsbl -0x1(%rsp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x23fa
movsbl -0x1(%rsp), %eax
cmpl $0x66, %eax
jg 0x23fa
movsbl -0x1(%rsp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x8(%rsp)
movsbl -0x1(%rsp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x2421
movsbl -0x1(%rsp), %eax
cmpl $0x46, %eax
jg 0x2421
movsbl -0x1(%rsp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: hexstr_to_bytes(unsigned char*, unsigned long, char*)
size_t hexstr_to_bytes(uint8_t *dst, size_t dst_size, char *hexstr)
{
	unsigned int len = strlen(hexstr);
	if (dst_size > (len/2))
	{
		dst_size = (len/2);
	}
	memset (dst,0,dst_size);
	for (unsigned int i=0; i < dst_size*2; i++)
	{
		unsigned int shift = 4 - 4 * (i & 1);
		unsigned int charIndex = i; //len-1-i;
		char c = hexstr[charIndex];
		uint8_t nibble = hexdigit_value (c);
		dst[i/2] |= nibble << shift;
	}
	return dst_size;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x20a0
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movl 0x1c(%rsp), %ecx
shrl %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x24a0
movl 0x1c(%rsp), %eax
shrl %eax
movl %eax, %eax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
xorl %esi, %esi
callq 0x20d0
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x28(%rsp), %rcx
shlq %rcx
cmpq %rcx, %rax
jae 0x2533
movl 0x18(%rsp), %ecx
andl $0x1, %ecx
shll $0x2, %ecx
movl $0x4, %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x10(%rsp), %ecx
movb (%rax,%rcx), %al
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %edi
callq 0x23a0
movb %al, 0xe(%rsp)
movzbl 0xe(%rsp), %esi
movl 0x14(%rsp), %ecx
shll %cl, %esi
movq 0x30(%rsp), %rax
movl 0x18(%rsp), %ecx
shrl %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x24b9
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: cleanup_hexstr(char*, unsigned long, char*, unsigned long)
size_t cleanup_hexstr(char *hexstr, size_t hexstr_size, char *str, size_t str_size)
{
	size_t cnt=0;
	int lastIs0=0;
	for (unsigned int j=0; j < str_size; j++)
	{
		char c = str[j];
		if (is_hexdigit (c))
		{
			if (cnt == hexstr_size-1) // need final char for null
			{
				printf ("Too many hex digits. hexstr=%s\n", hexstr);
				hexstr[cnt] = 0;
				return -1;
			}
			hexstr[cnt++] = c;
		}
		else if (lastIs0)
		{
			if ('x' == c)
			{
				cnt--;
			}
			if('X'==c)
			{
				cnt--;
			}
		}
		lastIs0 = '0' == c;
	}
	hexstr[cnt] = 0;
	return cnt;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpq 0x20(%rsp), %rax
jae 0x26cb
movq 0x28(%rsp), %rax
movl 0x10(%rsp), %ecx
movb (%rax,%rcx), %al
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %edi
callq 0x2430
cmpl $0x0, %eax
je 0x2660
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x2641
movq 0x38(%rsp), %rsi
leaq 0x59ff(%rip), %rdi      # 0x801d
movb $0x0, %al
callq 0x2030
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq $-0x1, 0x40(%rsp)
jmp 0x26e3
movb 0xf(%rsp), %dl
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rsp)
movb %dl, (%rax,%rcx)
jmp 0x26a3
cmpl $0x0, 0x14(%rsp)
je 0x26a1
movsbl 0xf(%rsp), %ecx
movl $0x78, %eax
cmpl %ecx, %eax
jne 0x2683
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
movsbl 0xf(%rsp), %ecx
movl $0x58, %eax
cmpl %ecx, %eax
jne 0x269f
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x26a1
jmp 0x26a3
movsbl 0xf(%rsp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x25d1
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: cgvwzq[P]aes_bf/include/aes_ni.h
// Function: aes128_self_test()
static int aes128_self_test(void){
    uint8_t plain[]      = {0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d, 0x31, 0x31, 0x98, 0xa2, 0xe0, 0x37, 0x07, 0x34};
    uint8_t enc_key[]    = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
    uint8_t cipher[]     = {0x39, 0x25, 0x84, 0x1d, 0x02, 0xdc, 0x09, 0xfb, 0xdc, 0x11, 0x85, 0x97, 0x19, 0x6a, 0x0b, 0x32};
    uint8_t computed_cipher[16];
    uint8_t computed_plain[16];
    int out=0;
    __m128i key_schedule[20];
    aes128_load_key(enc_key,key_schedule);
    aes128_enc(key_schedule,plain,computed_cipher);
    aes128_dec(key_schedule,cipher,computed_plain);
    if(memcmp(cipher,computed_cipher,sizeof(cipher))) out=1;
    if(memcmp(plain,computed_plain,sizeof(plain))) out|=2;
    return out;
}

// Assembly:
subq $0x1a8, %rsp            # imm = 0x1A8
movq 0x4372(%rip), %rax      # 0x84a0
movq %rax, 0x190(%rsp)
movq 0x436b(%rip), %rax      # 0x84a8
movq %rax, 0x198(%rsp)
movq 0x4364(%rip), %rax      # 0x84b0
movq %rax, 0x180(%rsp)
movq 0x435d(%rip), %rax      # 0x84b8
movq %rax, 0x188(%rsp)
movq 0x4356(%rip), %rax      # 0x84c0
movq %rax, 0x170(%rsp)
movq 0x434f(%rip), %rax      # 0x84c8
movq %rax, 0x178(%rsp)
movl $0x0, 0x14c(%rsp)
leaq 0x180(%rsp), %rdi
movq %rsp, %rsi
callq 0x4250
movq %rsp, %rdi
leaq 0x190(%rsp), %rsi
leaq 0x160(%rsp), %rdx
callq 0x47b0
movq %rsp, %rdi
leaq 0x170(%rsp), %rsi
leaq 0x150(%rsp), %rdx
callq 0x44c0
leaq 0x170(%rsp), %rax
leaq 0x160(%rsp), %rcx
vmovdqu (%rcx), %xmm1
vmovdqu (%rax), %xmm0
vpxor %xmm1, %xmm0, %xmm0
vptest %xmm0, %xmm0
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4203
movl $0x1, 0x14c(%rsp)
leaq 0x190(%rsp), %rax
leaq 0x150(%rsp), %rcx
vmovdqu (%rcx), %xmm1
vmovdqu (%rax), %xmm0
vpxor %xmm1, %xmm0, %xmm0
vptest %xmm0, %xmm0
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4240
movl 0x14c(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14c(%rsp)
movl 0x14c(%rsp), %eax
addq $0x1a8, %rsp            # imm = 0x1A8
retq
nop
// File: cgvwzq[P]aes_bf/include/aes_ni.h
// Function: aes128_load_key(unsigned char*, long long vector[2]*)
static void aes128_load_key(uint8_t *enc_key, __m128i *key_schedule){
    aes128_load_key_enc_only(enc_key, key_schedule);

    // generate decryption keys in reverse order.
    // k[10] is shared by last encryption and first decryption rounds
    // k[0] is shared by first encryption round and last decryption round (and is the original user key)
    // For some implementation reasons, decryption key schedule is NOT the encryption key schedule in reverse order
    key_schedule[11] = _mm_aesimc_si128(key_schedule[9]);
    key_schedule[12] = _mm_aesimc_si128(key_schedule[8]);
    key_schedule[13] = _mm_aesimc_si128(key_schedule[7]);
    key_schedule[14] = _mm_aesimc_si128(key_schedule[6]);
    key_schedule[15] = _mm_aesimc_si128(key_schedule[5]);
    key_schedule[16] = _mm_aesimc_si128(key_schedule[4]);
    key_schedule[17] = _mm_aesimc_si128(key_schedule[3]);
    key_schedule[18] = _mm_aesimc_si128(key_schedule[2]);
    key_schedule[19] = _mm_aesimc_si128(key_schedule[1]);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x4a80
movq (%rsp), %rax
vmovdqa 0x90(%rax), %xmm0
vmovdqa %xmm0, 0x90(%rsp)
vmovdqa 0x90(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq (%rsp), %rax
vmovdqa %xmm0, 0xb0(%rax)
movq (%rsp), %rax
vmovdqa 0x80(%rax), %xmm0
vmovdqa %xmm0, 0x80(%rsp)
vmovdqa 0x80(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq (%rsp), %rax
vmovdqa %xmm0, 0xc0(%rax)
movq (%rsp), %rax
vmovdqa 0x70(%rax), %xmm0
vmovdqa %xmm0, 0x70(%rsp)
vmovdqa 0x70(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq (%rsp), %rax
vmovdqa %xmm0, 0xd0(%rax)
movq (%rsp), %rax
vmovdqa 0x60(%rax), %xmm0
vmovdqa %xmm0, 0x60(%rsp)
vmovdqa 0x60(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq (%rsp), %rax
vmovdqa %xmm0, 0xe0(%rax)
movq (%rsp), %rax
vmovdqa 0x50(%rax), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
vmovdqa 0x50(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq (%rsp), %rax
vmovdqa %xmm0, 0xf0(%rax)
movq (%rsp), %rax
vmovdqa 0x40(%rax), %xmm0
vmovdqa %xmm0, 0x40(%rsp)
vmovdqa 0x40(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq (%rsp), %rax
vmovdqa %xmm0, 0x100(%rax)
movq (%rsp), %rax
vmovdqa 0x30(%rax), %xmm0
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x30(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq (%rsp), %rax
vmovdqa %xmm0, 0x110(%rax)
movq (%rsp), %rax
vmovdqa 0x20(%rax), %xmm0
vmovdqa %xmm0, 0x20(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq (%rsp), %rax
vmovdqa %xmm0, 0x120(%rax)
movq (%rsp), %rax
vmovdqa 0x10(%rax), %xmm0
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x10(%rsp), %xmm0
vaesimc %xmm0, %xmm0
movq (%rsp), %rax
vmovdqa %xmm0, 0x130(%rax)
addq $0xa8, %rsp
retq
nop
// File: cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: print_128(char const*, unsigned char const*, char const*)
static
void print_128(const char m[], const uint8_t a[16], const char m2[])
{
	print_bytes_sep (m, a, 4, "_", "");
	print_bytes_sep ("", a+4 , 4, "_", "");
	print_bytes_sep ("", a+8 , 4, "_", "");
	print_bytes_sep ("", a+12, 4, m2, "");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x4, %edx
leaq 0x3fca(%rip), %rcx      # 0x8402
leaq 0x3dd0(%rip), %r8       # 0x820f
callq 0x4d10
movq 0x8(%rsp), %rsi
addq $0x4, %rsi
leaq 0x3dbb(%rip), %r8       # 0x820f
movl $0x4, %edx
leaq 0x3fa2(%rip), %rcx      # 0x8402
movq %r8, %rdi
callq 0x4d10
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x3d97(%rip), %r8       # 0x820f
movl $0x4, %edx
leaq 0x3f7e(%rip), %rcx      # 0x8402
movq %r8, %rdi
callq 0x4d10
movq 0x8(%rsp), %rsi
addq $0xc, %rsi
movq (%rsp), %rcx
leaq 0x3d6f(%rip), %r8       # 0x820f
movl $0x4, %edx
movq %r8, %rdi
callq 0x4d10
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cgvwzq[P]aes_bf/include/aes_ni.h
// Function: aes128_load_key_enc_only(unsigned char*, long long vector[2]*)
static void aes128_load_key_enc_only(uint8_t *enc_key, __m128i *key_schedule){
    key_schedule[0] = _mm_loadu_si128((const __m128i*) enc_key);
    key_schedule[1]  = AES_128_key_exp(key_schedule[0], 0x01);
    key_schedule[2]  = AES_128_key_exp(key_schedule[1], 0x02);
    key_schedule[3]  = AES_128_key_exp(key_schedule[2], 0x04);
    key_schedule[4]  = AES_128_key_exp(key_schedule[3], 0x08);
    key_schedule[5]  = AES_128_key_exp(key_schedule[4], 0x10);
    key_schedule[6]  = AES_128_key_exp(key_schedule[5], 0x20);
    key_schedule[7]  = AES_128_key_exp(key_schedule[6], 0x40);
    key_schedule[8]  = AES_128_key_exp(key_schedule[7], 0x80);
    key_schedule[9]  = AES_128_key_exp(key_schedule[8], 0x1B);
    key_schedule[10] = AES_128_key_exp(key_schedule[9], 0x36);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
vmovdqu (%rax), %xmm0
movq (%rsp), %rax
vmovdqa %xmm0, (%rax)
movq (%rsp), %rax
vmovdqa (%rax), %xmm0
movq (%rsp), %rax
vmovdqa (%rax), %xmm1
vaeskeygenassist $0x1, %xmm1, %xmm1
callq 0x4c40
movq (%rsp), %rax
vmovdqa %xmm0, 0x10(%rax)
movq (%rsp), %rax
vmovdqa 0x10(%rax), %xmm0
movq (%rsp), %rax
vmovdqa 0x10(%rax), %xmm1
vaeskeygenassist $0x2, %xmm1, %xmm1
callq 0x4c40
movq (%rsp), %rax
vmovdqa %xmm0, 0x20(%rax)
movq (%rsp), %rax
vmovdqa 0x20(%rax), %xmm0
movq (%rsp), %rax
vmovdqa 0x20(%rax), %xmm1
vaeskeygenassist $0x4, %xmm1, %xmm1
callq 0x4c40
movq (%rsp), %rax
vmovdqa %xmm0, 0x30(%rax)
movq (%rsp), %rax
vmovdqa 0x30(%rax), %xmm0
movq (%rsp), %rax
vmovdqa 0x30(%rax), %xmm1
vaeskeygenassist $0x8, %xmm1, %xmm1
callq 0x4c40
movq (%rsp), %rax
vmovdqa %xmm0, 0x40(%rax)
movq (%rsp), %rax
vmovdqa 0x40(%rax), %xmm0
movq (%rsp), %rax
vmovdqa 0x40(%rax), %xmm1
vaeskeygenassist $0x10, %xmm1, %xmm1
callq 0x4c40
movq (%rsp), %rax
vmovdqa %xmm0, 0x50(%rax)
movq (%rsp), %rax
vmovdqa 0x50(%rax), %xmm0
movq (%rsp), %rax
vmovdqa 0x50(%rax), %xmm1
vaeskeygenassist $0x20, %xmm1, %xmm1
callq 0x4c40
movq (%rsp), %rax
vmovdqa %xmm0, 0x60(%rax)
movq (%rsp), %rax
vmovdqa 0x60(%rax), %xmm0
movq (%rsp), %rax
vmovdqa 0x60(%rax), %xmm1
vaeskeygenassist $0x40, %xmm1, %xmm1
callq 0x4c40
movq (%rsp), %rax
vmovdqa %xmm0, 0x70(%rax)
movq (%rsp), %rax
vmovdqa 0x70(%rax), %xmm0
movq (%rsp), %rax
vmovdqa 0x70(%rax), %xmm1
vaeskeygenassist $0x80, %xmm1, %xmm1
callq 0x4c40
movq (%rsp), %rax
vmovdqa %xmm0, 0x80(%rax)
movq (%rsp), %rax
vmovdqa 0x80(%rax), %xmm0
movq (%rsp), %rax
vmovdqa 0x80(%rax), %xmm1
vaeskeygenassist $0x1b, %xmm1, %xmm1
callq 0x4c40
movq (%rsp), %rax
vmovdqa %xmm0, 0x90(%rax)
movq (%rsp), %rax
vmovdqa 0x90(%rax), %xmm0
movq (%rsp), %rax
vmovdqa 0x90(%rax), %xmm1
vaeskeygenassist $0x36, %xmm1, %xmm1
callq 0x4c40
movq (%rsp), %rax
vmovdqa %xmm0, 0xa0(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: cgvwzq[P]aes_bf/include/aes_ni.h
// Function: aes_128_key_expansion(long long vector[2], long long vector[2])
static __m128i aes_128_key_expansion(__m128i key, __m128i keygened){
    keygened = _mm_shuffle_epi32(keygened, _MM_SHUFFLE(3,3,3,3));
    key = _mm_xor_si128(key, _mm_slli_si128(key, 4));
    key = _mm_xor_si128(key, _mm_slli_si128(key, 4));
    key = _mm_xor_si128(key, _mm_slli_si128(key, 4));
    return _mm_xor_si128(key, keygened);
}

// Assembly:
subq $0x28, %rsp
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa %xmm1, -0x80(%rsp)
vpbroadcastd -0x74(%rsp), %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x70(%rsp), %xmm1
vpslldq $0x4, %xmm1, %xmm0      # xmm0 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
vmovdqa %xmm1, 0x10(%rsp)
vmovdqa %xmm0, (%rsp)
vmovdqa 0x10(%rsp), %xmm0
vmovdqa (%rsp), %xmm1
vpxor %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa -0x70(%rsp), %xmm1
vpslldq $0x4, %xmm1, %xmm0      # xmm0 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
vmovdqa %xmm1, -0x10(%rsp)
vmovdqa %xmm0, -0x20(%rsp)
vmovdqa -0x10(%rsp), %xmm0
vmovdqa -0x20(%rsp), %xmm1
vpxor %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa -0x70(%rsp), %xmm1
vpslldq $0x4, %xmm1, %xmm0      # xmm0 = zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
vmovdqa %xmm1, -0x30(%rsp)
vmovdqa %xmm0, -0x40(%rsp)
vmovdqa -0x30(%rsp), %xmm0
vpxor -0x40(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa -0x70(%rsp), %xmm1
vmovdqa -0x80(%rsp), %xmm0
vmovdqa %xmm1, -0x50(%rsp)
vmovdqa %xmm0, -0x60(%rsp)
vmovdqa -0x50(%rsp), %xmm0
vpxor -0x60(%rsp), %xmm0, %xmm0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: print_bytes_sep(char const*, unsigned char const*, unsigned int, char const*, char const*)
static
void print_bytes_sep(const char *msg,const unsigned char *buf, unsigned int size, const char m2[], const char sep[])
{
    unsigned int i;
    printf ("%s", msg);
    for (i=0; i < size-1; i++)
	{
		printf ("%02X%s", buf[i], sep);
	}
    if (i < size)
	{
		printf ("%02X", buf[i]);
	}
    printf ("%s", m2);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x36d0(%rip), %rdi      # 0x8408
movb $0x0, %al
callq 0x2030
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x4d83
movq 0x28(%rsp), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %esi
movq 0x10(%rsp), %rdx
leaq 0x3695(%rip), %rdi      # 0x8404
movb $0x0, %al
callq 0x2030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4d47
movl 0xc(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x4da8
movq 0x28(%rsp), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %esi
leaq 0x3277(%rip), %rdi      # 0x8018
movb $0x0, %al
callq 0x2030
movq 0x18(%rsp), %rsi
leaq 0x3654(%rip), %rdi      # 0x8408
movb $0x0, %al
callq 0x2030
addq $0x38, %rsp
retq
// File: cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: aes_brute_force::mask_to_offsets(unsigned char*, unsigned char*, voffset*)
static
	void mask_to_offsets(uint8_t cipher_mask[16], uint8_t next_block[16], voffset_t *v)
	{
		v->n_offsets = 0;
		for (unsigned int i=0; i < 16; i++)
		{
			v->next[i] = next_block[i];
			if (cipher_mask[i]) 
			{
				v->offsets[v->n_offsets++] = i;
				uint8_t count = 0;
				for (unsigned int j=0x33; j < 0x7f; j++)
				{
					// generate range of valid chars for each byte
					if (j != 0x3b && j != 0x3d && j != 0x22)
					{
						v->valid_chars[i][count++] = j ^ v->next[i];
					}
				}
				v->n_valid_chars = count;
			}
		}
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
movb $0x0, 0x10(%rax)
movl $0x0, -0x1c(%rsp)
cmpl $0x10, -0x1c(%rsp)
jae 0x4eda
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
movb (%rax,%rcx), %dl
movq -0x18(%rsp), %rax
movl -0x1c(%rsp), %ecx
movb %dl, 0x1012(%rax,%rcx)
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
cmpb $0x0, (%rax,%rcx)
je 0x4ec8
movl -0x1c(%rsp), %eax
movb %al, %dl
movq -0x18(%rsp), %rax
movq -0x18(%rsp), %rsi
movb 0x10(%rsi), %cl
movb %cl, %dil
addb $0x1, %dil
movb %dil, 0x10(%rsi)
movzbl %cl, %ecx
movb %dl, (%rax,%rcx)
movb $0x0, -0x1d(%rsp)
movl $0x33, -0x24(%rsp)
cmpl $0x7f, -0x24(%rsp)
jae 0x4eb9
cmpl $0x3b, -0x24(%rsp)
je 0x4eaa
cmpl $0x3d, -0x24(%rsp)
je 0x4eaa
cmpl $0x22, -0x24(%rsp)
je 0x4eaa
movl -0x24(%rsp), %eax
movq -0x18(%rsp), %rcx
movl -0x1c(%rsp), %edx
movzbl 0x1012(%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x18(%rsp), %rax
addq $0x11, %rax
movl -0x1c(%rsp), %ecx
shlq $0x8, %rcx
addq %rcx, %rax
movb -0x1d(%rsp), %cl
movb %cl, %sil
addb $0x1, %sil
movb %sil, -0x1d(%rsp)
movzbl %cl, %ecx
movb %dl, (%rax,%rcx)
jmp 0x4eac
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x4e4b
movb -0x1d(%rsp), %cl
movq -0x18(%rsp), %rax
movb %cl, 0x1011(%rax)
jmp 0x4eca
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x4de0
retq
nopl (%rax,%rax)
// File: cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: aes_brute_force::aes_brute_force(unsigned char*, unsigned char*, unsigned char*, unsigned char*, unsigned char*, unsigned char*, unsigned char*)
explicit aes_brute_force(uint8_t cipher_mask[16], uint8_t cipher[16], uint8_t key[16], uint8_t iv[16], uint8_t plain_mask[16], uint8_t plain[16], uint8_t next_block[16])
	{
		aes128_block_t b;

		memcpy (&b, cipher, 16);
		memcpy (this->cipher_mask, cipher_mask, 16);
		memcpy (this->key, key, 16);
		memcpy (this->iv, iv, 16);
		memcpy (this->plain_mask, plain_mask, 16);
		memcpy (this->plain, plain, 16);
		memcpy (this->next_block, next_block, 16);

		blocks.push_back (b);
		mask_to_offsets (cipher_mask, next_block, &this->v);
		nbits = this->v.n_offsets * 8;
	}

// Assembly:
subq $0x68, %rsp
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x1040, %rdi           # imm = 0x1040
movq %rdi, 0x8(%rsp)
callq 0x5680
movq (%rsp), %rax
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rcx
vmovdqu (%rcx), %xmm0
vmovdqa %xmm0, 0x20(%rsp)
movq 0x58(%rsp), %rcx
vmovdqu (%rcx), %xmm0
vmovdqu %xmm0, 0x10a8(%rax)
movq 0x48(%rsp), %rcx
vmovdqu (%rcx), %xmm0
vmovdqu %xmm0, 0x1058(%rax)
movq 0x40(%rsp), %rcx
vmovdqu (%rcx), %xmm0
vmovdqu %xmm0, 0x1068(%rax)
movq 0x38(%rsp), %rcx
vmovdqu (%rcx), %xmm0
vmovdqu %xmm0, 0x1088(%rax)
movq 0x70(%rsp), %rcx
vmovdqu (%rcx), %xmm0
vmovdqu %xmm0, 0x1078(%rax)
movq 0x78(%rsp), %rcx
vmovdqu (%rcx), %xmm0
vmovdqu %xmm0, 0x10b8(%rax)
leaq 0x20(%rsp), %rsi
callq 0x5690
jmp 0x5100
movq (%rsp), %rdx
movq 0x58(%rsp), %rdi
movq 0x78(%rsp), %rsi
addq $0x9, %rdx
callq 0x4dc0
movq (%rsp), %rax
movzbl 0x19(%rax), %ecx
shll $0x3, %ecx
movl %ecx, 0x102c(%rax)
addq $0x68, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x5700
movq 0x18(%rsp), %rdi
callq 0x2220
nop