LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::substring(int, int)
char* t_string::substring(int i, int j)
{
	//t_string* sub_str = new t_string();
	char* sub_str;

	// Validity checks on the arguments.
	if(i > j ||
		i > this->length() || 
		j > this->length())
	{
		return(NULL);
	}
	else
	{
		sub_str = (char*)malloc(sizeof(char) * (j-i+1+2));
		sub_str[0] = 0; // Make this an empty string.
	}

	// Copy the substring.
	int ip = i;
	int i_sub_str = 0;
	while(ip <= j)
	{
		sub_str[i_sub_str] = this->x(ip);

		i_sub_str++;
		ip++;
	}

	// End the string.
	sub_str[i_sub_str] = 0;

	return(sub_str);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jg 0x9e1b
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x9920
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jg 0x9e1b
movq 0x8(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, (%rsp)
callq 0x9920
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jle 0x9e29
movq $0x0, 0x30(%rsp)
jmp 0x9eb7
movl 0x20(%rsp), %eax
subl 0x24(%rsp), %eax
addl $0x1, %eax
addl $0x2, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2210
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x20(%rsp), %eax
jg 0x9e9f
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x9b30
movb (%rax), %dl
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x9e60
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::is_number(char*)
bool t_string::is_number(char* string)
{
	int cur_state = STR_STATE_PREFIX;

	for(int i = 0; ; i++)
	{
		if(string[i] == 0)
		{
			break;
		}

		if(string[i] == '+' || 
			string[i] == '-')
		{
			if(cur_state == STR_STATE_EXPO)
			{
			}
			else
			{
				cur_state = STR_STATE_WHOLE;
			}
		}
		else if(string[i] == '.')
		{
			// We can come to this state from whole or prefix state, not from decimal state.
			if(cur_state == STR_STATE_DECIMAL)
			{
				return(false);
			}

			cur_state = STR_STATE_DECIMAL;
		}
		else if(string[i] == ',')
		{
			// This is not allowed in decimal part of a number.
			if(cur_state == STR_STATE_DECIMAL ||
				cur_state == STR_STATE_PREFIX)
			{
				return(false);
			}
		}
		else if(string[i] >= '0' && string[i] <= '9')
		{	
			// Nothing changes.
		}
		else if(string[i] == 'e')
		{
			// Cannot get into this state again.
			if(cur_state == STR_STATE_EXPO)
			{
				return(false);
			}

			// If the state was prefix, move to whole.
			cur_state = STR_STATE_EXPO;

			if(string[i+1] == 0)
			{
				break;
			}
			
			// Otherwise nothing changes.
		}
		else
		{
			// Any other character is not acceptable as a number.
			return(false);
		}
	} // i loop.

	return(true);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x9f9d
jmp 0xa0c5
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
je 0x9fc3
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x9fd9
cmpl $0x3, -0x14(%rsp)
jne 0x9fcc
jmp 0x9fd4
movl $0x1, -0x14(%rsp)
jmp 0xa0b3
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0xa00a
cmpl $0x2, -0x14(%rsp)
jne 0x9ffd
movb $0x0, -0x1(%rsp)
jmp 0xa0ca
movl $0x2, -0x14(%rsp)
jmp 0xa0b1
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
jne 0xa037
cmpl $0x2, -0x14(%rsp)
je 0xa02b
cmpl $0x0, -0x14(%rsp)
jne 0xa035
movb $0x0, -0x1(%rsp)
jmp 0xa0ca
jmp 0xa0af
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0xa05f
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0xa05f
jmp 0xa0ad
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x65, %eax
jne 0xa0a4
cmpl $0x3, -0x14(%rsp)
jne 0xa080
movb $0x0, -0x1(%rsp)
jmp 0xa0ca
movl $0x3, -0x14(%rsp)
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xa0a2
jmp 0xa0c5
jmp 0xa0ab
movb $0x0, -0x1(%rsp)
jmp 0xa0ca
jmp 0xa0ad
jmp 0xa0af
jmp 0xa0b1
jmp 0xa0b3
jmp 0xa0b5
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x9f85
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::split_string_list(std::vector<char*, std::allocator<char*>>*, int)
vector<vector<char*>*>* t_string::split_string_list(vector<char*>* string_list, int n_batches)
{
	vector<vector<char*>*>* batches = new vector<vector<char*>*>();

	int n_string_per_batch = (int)string_list->size() / n_batches;
	vector<char*>* current_batch = new vector<char*>();
	batches->push_back(current_batch);
	for(int i_str = 0; i_str < (int)string_list->size(); i_str++)
	{
		if((int)current_batch->size() == n_string_per_batch)
		{
			current_batch = new vector<char*>();
			batches->push_back(current_batch);
		}

		current_batch->push_back(string_list->at(i_str));
	} // i_str loop.

	return(batches);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl $0x18, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x18(%rsp), %rdi
callq 0xd700
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0x4f10
cltd
idivl 0x4c(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x18, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, 0x20(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x20(%rsp), %rdi
callq 0x4fd0
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd710
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x50(%rsp), %rdi
callq 0x4f10
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0xa851
movq 0x30(%rsp), %rdi
callq 0x4f10
cmpl 0x3c(%rsp), %eax
jne 0xa81d
movl $0x18, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x8(%rsp), %rdi
callq 0x4fd0
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd710
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x4f70
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x7640
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xa7ab
movq 0x40(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::copy_tokens_2_strs(std::vector<t_string*, std::allocator<t_string*>>*)
vector<char*>* t_string::copy_tokens_2_strs(t_string_tokens* toks)
{
	vector<char*>* strs = new vector<char*>();
	for (int i_t = 0; i_t < toks->size(); i_t++)
	{
		strs->push_back(toks->at(i_t)->str());
	} // i_t loop.

	return(strs);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x18, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x10(%rsp), %rdi
callq 0x4fd0
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x75a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xb514
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x7600
movq (%rax), %rdi
callq 0x9490
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x4e70
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xb4b3
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::remove_beginning_spaces_tabs(char*)
char* t_string::remove_beginning_spaces_tabs(char* string)
{
	int i_last_space = 0;

	int l_str = t_string::string_length(string);

	for(int i = 0; i < l_str; i++)
	{
		if(string[i] != ' ' &&
			string[i] != '\t')
		{
			i_last_space = i;
			break;
		}
	}

	char* reloc_copy = new char[l_str + 2];

	// Relocate.
	copy(reloc_copy, &string[i_last_space]);
	
	return(reloc_copy);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x87e0
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0xbb60
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0xbb51
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0xbb51
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0xbb60
jmp 0xbb53
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xbb17
movl 0x18(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movslq 0x1c(%rsp), %rax
addq %rax, %rsi
callq 0x9240
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::compare_prefixes(char const*, char const*)
bool t_string::compare_prefixes(const char* str1, const char* str2)
{
	int i = 0;
	while(str1[i] && str2[i])
	{
		if(str1[i] != str2[i])
		{
			return(false);
		} // comparison.

		i++;
	} // i loop.

	return(true);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x10(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
xorl %eax, %eax
cmpb $0x0, (%rcx,%rdx)
movb %al, -0x1d(%rsp)
je 0xc9cd
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
setne %al
movb %al, -0x1d(%rsp)
movb -0x1d(%rsp), %al
testb $0x1, %al
jne 0xc9d7
jmp 0xca0b
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xc9fe
movb $0x0, -0x1(%rsp)
jmp 0xca10
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xc9a2
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::ends_with(char const*)
bool t_string::ends_with(const char* string)
{
	if(this->length() < string_length(string))
	{
		return(false);
	}

	// Go over all the characters of the sub-string and check if they match to the end of the string.
	int i_str = this->length() - 1;
	unsigned int i_sub = string_length(string) - 1;
	while(1)
	{
		if(string[i_sub] != this->x(i_str))
		{
			return(false);
		}

		if(i_sub == 0)
		{
			return(true);
		}
		else
		{
			i_sub--;
		}

		i_str--;		
	} // i loop.

	return(true);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x9920
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
callq 0x87e0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0xcbfc
movb $0x0, 0x37(%rsp)
jmp 0xcc78
movq 0x8(%rsp), %rdi
callq 0x9920
subl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x87e0
subl $0x1, %eax
movl %eax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %ecx
movsbl (%rax,%rcx), %eax
movl %eax, 0x4(%rsp)
movl 0x1c(%rsp), %esi
callq 0x9b30
movq %rax, %rcx
movl 0x4(%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0xcc52
movb $0x0, 0x37(%rsp)
jmp 0xcc78
cmpl $0x0, 0x18(%rsp)
jne 0xcc60
movb $0x1, 0x37(%rsp)
jmp 0xcc78
movl 0x18(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xcc1e
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::ends_with(char const*, char const*)
bool t_string::ends_with(const char* full_string, const char* sub_str)
{
	if(string_length(full_string) < string_length(sub_str))
	{
		return(false);
	}

	// Go over all the characters of the sub-string and check if they match to the end of the string.
	int i_str = string_length(full_string) - 1;
	unsigned int i_sub = string_length(sub_str) - 1;
	while(1)
	{
		if(sub_str[i_sub] != full_string[i_str])
		{
			return(false);
		}

		if(i_sub == 0)
		{
			return(true);
		}
		else
		{
			i_sub--;
		}

		i_str--;		
	} // i loop.

	return(true);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x87e0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0x87e0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0xce77
movb $0x0, 0x27(%rsp)
jmp 0xcee5
movq 0x18(%rsp), %rdi
callq 0x87e0
subl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x87e0
subl $0x1, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %ecx
movsbl (%rax,%rcx), %eax
movq 0x18(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xcebf
movb $0x0, 0x27(%rsp)
jmp 0xcee5
cmpl $0x0, 0x8(%rsp)
jne 0xcecd
movb $0x1, 0x27(%rsp)
jmp 0xcee5
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xce99
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: pstuifzand[P]magento-tools/src/magento-helpers.cpp
// Function: find_code_pool(char const*)
CodePool find_code_pool(const char* filename) {
    int n         = strlen(filename);
    const char* p = filename;

    while (1) {
        if (strncmp("app/code/", p, 9) == 0) {
            p += 9;
            n -= 9;
            break;
        }
        while (n && *p != '/') { ++p; --n; }
        if (!n) break;
        ++p; --n;
    }
    if (strncmp("cor", p, 3) == 0) return CodePool::CORE;
    if (strncmp("com", p, 3) == 0) return CodePool::COMMUNITY;
    if (strncmp("loc", p, 3) == 0) return CodePool::LOCAL;
    return CodePool::ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0xc79(%rip), %rdi       # 0x3004
movl $0x9, %edx
callq 0x20a0
cmpl $0x0, %eax
jne 0x23b1
movq -0x20(%rbp), %rax
addq $0x9, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
subl $0x9, %eax
movl %eax, -0x14(%rbp)
jmp 0x2410
jmp 0x23b3
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x21(%rbp)
je 0x23ce
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x23d7
jmp 0x23ee
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x23b3
cmpl $0x0, -0x14(%rbp)
jne 0x23f6
jmp 0x2410
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2380
movq -0x20(%rbp), %rsi
leaq 0xbf3(%rip), %rdi       # 0x300e
movl $0x3, %edx
callq 0x20a0
cmpl $0x0, %eax
jne 0x2433
movl $0x0, -0x4(%rbp)
jmp 0x2480
movq -0x20(%rbp), %rsi
leaq 0xbd4(%rip), %rdi       # 0x3012
movl $0x3, %edx
callq 0x20a0
cmpl $0x0, %eax
jne 0x2456
movl $0x1, -0x4(%rbp)
jmp 0x2480
movq -0x20(%rbp), %rsi
leaq 0xbb5(%rip), %rdi       # 0x3016
movl $0x3, %edx
callq 0x20a0
cmpl $0x0, %eax
jne 0x2479
movl $0x2, -0x4(%rbp)
jmp 0x2480
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: pstuifzand[P]magento-tools/src/magento-helpers.cpp
// Function: root_start_element_handler(void*, char const*, char const**)
void root_start_element_handler(void* udata, const XML_Char* name, const XML_Char** atts) {
    user_data* data = (user_data*)udata;

    switch (data->state) {
        case State::WAIT_FOR_SECTION: {
            if (strcmp("helpers", name) == 0) data->state = State::IN_HELPERS;
            if (strcmp("models", name) == 0) data->state = State::IN_MODELS;
            if (strcmp("blocks", name) == 0) data->state = State::IN_BLOCKS;
        } break;

        case State::IN_HELPERS:
        case State::IN_MODELS:
        case State::IN_BLOCKS: {
            // here is a tag with a variable name
            data->name.assign(name);
            data->state = start_element_next_state[int(data->state)];
        } break;

        case State::IN_HELPER:
        case State::IN_BLOCK:
        case State::IN_MODEL: {
            if (strcmp("class", name) == 0) data->state = start_element_next_state[int(data->state)];
        } break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x250f
jmp 0x24bc
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x256e
jmp 0x24ca
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0x2598
jmp 0x24d8
movl -0x24(%rbp), %eax
subl $0x5, %eax
je 0x256e
jmp 0x24e6
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0x2598
jmp 0x24f4
movl -0x24(%rbp), %eax
subl $0x8, %eax
je 0x256e
jmp 0x24fe
movl -0x24(%rbp), %eax
subl $0x9, %eax
je 0x2598
jmp 0x25c6
movq -0x10(%rbp), %rsi
leaq 0xb00(%rip), %rdi       # 0x301a
callq 0x2190
cmpl $0x0, %eax
jne 0x252e
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rsi
leaq 0xae9(%rip), %rdi       # 0x3022
callq 0x2190
cmpl $0x0, %eax
jne 0x254d
movq -0x20(%rbp), %rax
movl $0x5, (%rax)
movq -0x10(%rbp), %rsi
leaq 0xad1(%rip), %rdi       # 0x3029
callq 0x2190
cmpl $0x0, %eax
jne 0x256c
movq -0x20(%rbp), %rax
movl $0x8, (%rax)
jmp 0x25c6
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x2200
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
leaq 0xb03(%rip), %rax       # 0x3090
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x25c6
movq -0x10(%rbp), %rsi
leaq 0xa8d(%rip), %rdi       # 0x3030
callq 0x2190
cmpl $0x0, %eax
jne 0x25c4
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
leaq 0xad5(%rip), %rax       # 0x3090
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x25c6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: pstuifzand[P]magento-tools/src/magento-helpers.cpp
// Function: character_data_handler(void*, char const*, int)
void character_data_handler(void* udata, const XML_Char* s, int len) {
    user_data* data = (user_data*)udata;
    switch (data->state) {
        case State::IN_HELPER_CLASS:
        case State::IN_MODEL_CLASS:
        case State::IN_BLOCK_CLASS:
            data->current_text.append(s, len);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x4, %eax
je 0x281f
jmp 0x280b
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x281f
jmp 0x2815
movl -0x24(%rbp), %eax
subl $0xa, %eax
jne 0x2834
jmp 0x281f
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2040
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iannisdezwart[P]forcefield-visualiser/./colour.hpp
// Function: force_to_rgb(Vector<2, double>)
png::rgb_pixel force_to_rgb(Vector<2> force)
{
	// Get the angle and the length of the vector

	double angle = force.angle();

	// Calculate the corresponding hue

	png::rgb_pixel pixel = angle_to_rgb(angle);

	// Calculate the normalised force

	double normalised_force = tanh(force.length() * 20.0);

	// Set the lightness

	int inverse_red = 255 - pixel.red;
	int inverse_green = 255 - pixel.green;
	int inverse_blue = 255 - pixel.blue;

	pixel.red += inverse_red * normalised_force * 0.85;
	pixel.green += inverse_green * normalised_force * 0.85;
	pixel.blue += inverse_blue * normalised_force * 0.85;

	return pixel;
}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5c10
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x3830
movq 0x8(%rsp), %rdi
movw %ax, %cx
movw %cx, 0x45(%rsp)
shrl $0x10, %eax
movb %al, 0x47(%rsp)
callq 0x5c30
movsd 0xb61f(%rip), %xmm1     # 0xf030
mulsd %xmm1, %xmm0
callq 0x30a0
movsd %xmm0, 0x20(%rsp)
movzbl 0x45(%rsp), %eax
xorl $0xff, %eax
movl %eax, 0x1c(%rsp)
movzbl 0x46(%rsp), %eax
xorl $0xff, %eax
movl %eax, 0x18(%rsp)
movzbl 0x47(%rsp), %eax
xorl $0xff, %eax
movl %eax, 0x14(%rsp)
cvtsi2sdl 0x1c(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm0
movzbl 0x45(%rsp), %eax
cvtsi2sd %eax, %xmm1
movsd 0xb5cd(%rip), %xmm2     # 0xf038
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, 0x45(%rsp)
cvtsi2sdl 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm0
movzbl 0x46(%rsp), %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, 0x46(%rsp)
cvtsi2sdl 0x14(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm0
movzbl 0x47(%rsp), %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
movb %al, 0x12(%rsp)
movw 0x45(%rsp), %ax
movw %ax, 0x10(%rsp)
movzbl 0x12(%rsp), %ecx
shll $0x10, %ecx
movzwl 0x10(%rsp), %eax
orl %ecx, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iannisdezwart[P]forcefield-visualiser/./mass.hpp
// Function: get_masses_from_user_input()
void get_masses_from_user_input()
{
	int number_of_masses;
	cin >> number_of_masses;

	for (int i = 0; i < number_of_masses; i++) {
		int x, y, weight;
		cin >> x >> y >> weight;

		Mass mass(x, y, weight);
		masses.push_back(mass);
	}
}

// Assembly:
subq $0x38, %rsp
movq 0x114d5(%rip), %rdi     # 0x14fe0
leaq 0x34(%rsp), %rsi
callq 0x31f0
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x3b86
movq 0x114b2(%rip), %rdi     # 0x14fe0
leaq 0x2c(%rsp), %rsi
callq 0x31f0
movq %rax, %rdi
leaq 0x28(%rsp), %rsi
callq 0x31f0
movq %rax, %rdi
leaq 0x24(%rsp), %rsi
callq 0x31f0
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x24(%rsp), %ecx
leaq 0x8(%rsp), %rdi
callq 0x5d10
leaq 0x117f1(%rip), %rdi     # 0x15360
leaq 0x8(%rsp), %rsi
callq 0x5db0
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x3b1d
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: iannisdezwart[P]forcefield-visualiser/./forces.hpp
// Function: calculate_resulting_force(Vector<2, double>)
Vector<2> calculate_resulting_force(Vector<2> pixel_position)
{
	Vector<2> resulting_force;

	// For each mass ...

	for (int i = 0; i < masses.size(); i++) {
		// ... we calculate the vector from the pixel to the mass ...

		Vector<2> pixel_to_mass = masses[i].position - pixel_position;

		// ... and we calculate the angle and the inverse distance of this vector ...

		double angle = pixel_to_mass.angle();
		double inverse_distance = masses[i].weight / pixel_to_mass.length();

		// ... with these we construct a normalised `Vector<2> force_vector`,
		// which we multiply by the scalar `double inverse_distance` ...

		Vector<2> force_vector = Vector<2>::from_angle(angle) * inverse_distance;

		// ... and add the current `force_vector` to the `resulting_force`.

		resulting_force += force_vector;
	}

	return resulting_force;
}

// Assembly:
subq $0xb8, %rsp
movsd %xmm0, 0x98(%rsp)
movsd %xmm1, 0xa0(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x5e20
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0xa8(%rsp), %rdi
callq 0x5e40
movl $0x0, 0x84(%rsp)
movslq 0x84(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x1176e(%rip), %rdi     # 0x15360
callq 0x5f10
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x3d22
movslq 0x84(%rsp), %rsi
leaq 0x11749(%rip), %rdi     # 0x15360
callq 0x5f30
movq %rax, %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x68(%rsp)
movsd 0x60(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
callq 0x5f50
movsd %xmm0, 0x70(%rsp)
movsd %xmm1, 0x78(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x5c10
movsd %xmm0, 0x58(%rsp)
movslq 0x84(%rsp), %rsi
leaq 0x116eb(%rip), %rdi     # 0x15360
callq 0x5f30
cvtsi2sdl 0x10(%rax), %xmm0
movsd %xmm0, (%rsp)
leaq 0x70(%rsp), %rdi
callq 0x5c30
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x58(%rsp), %xmm0
callq 0x5fe0
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x38(%rsp)
movsd 0x50(%rsp), %xmm0
leaq 0x30(%rsp), %rdi
callq 0x6050
movsd %xmm0, 0x40(%rsp)
movsd %xmm1, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
leaq 0xa8(%rsp), %rdi
callq 0x60e0
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x3bde
movsd 0xa8(%rsp), %xmm0
movsd 0xb0(%rsp), %xmm1
addq $0xb8, %rsp
retq
nopl (%rax)
// File: iannisdezwart[P]forcefield-visualiser/./rendering.hpp
// Function: render_rows(int, int)
void render_rows(int start_row, int increment)
{
	// Render each pixel of the given rows

	Vector<2> current_position;

	// Start `int y` at the `start_row` and increment it by `increment` each time

	for (int y = start_row; y < HEIGHT; y += increment) {
		current_position[1] = y;

		for (int x = 0; x < WIDTH; x++) {
			current_position[0] = x;

			// Render the current pixel

			render_pixel(current_position);
		}
	}
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movl %esi, 0x50(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5e20
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x5e40
movl 0x54(%rsp), %eax
movl %eax, 0x2c(%rsp)
cmpl $0x438, 0x2c(%rsp)      # imm = 0x438
jge 0x3f2e
cvtsi2sdl 0x2c(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x6240
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movl $0x0, 0x28(%rsp)
cmpl $0x780, 0x28(%rsp)      # imm = 0x780
jge 0x3f1b
cvtsi2sdl 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x6240
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x3d40
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x3ebd
jmp 0x3f1d
movl 0x50(%rsp), %eax
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x3e82
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iannisdezwart[P]forcefield-visualiser/./motion.hpp
// Function: motion::render_image_from_user_input()
void render_image_from_user_input()
	{
		// Get the masses from stdin

		get_masses_from_user_input();

		// Render the image

		render_image("output/1.png", MULTI_THREADED);
	}

// Assembly:
subq $0x48, %rsp
callq 0x3b00
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x35b0
movq 0x8(%rsp), %rdx
leaq 0x961c(%rip), %rsi      # 0xf0d0
leaq 0x28(%rsp), %rdi
callq 0x6b00
jmp 0x5ac0
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x3f40
jmp 0x5ad1
leaq 0x28(%rsp), %rdi
callq 0x3200
leaq 0x27(%rsp), %rdi
callq 0x3360
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x5b12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3200
leaq 0x27(%rsp), %rdi
callq 0x3360
movq 0x18(%rsp), %rdi
callq 0x3590
nopw %cs:(%rax,%rax)
// File: iannisdezwart[P]forcefield-visualiser/index.cpp
// Function: main
int main()
{
	// Store the current timestamp to measure the execution time

	auto start = chrono::high_resolution_clock::now();

	// Replace this function with what you want to render
	// Some example functions are written in `motion.hpp`

	motion::four_body();

	// Print the execution time

	auto stop = chrono::high_resolution_clock::now();
	auto duration = chrono::duration_cast<chrono::milliseconds>(stop - start);

	cout << "Total execution time: " << duration.count() << " ms\n";
}

// Assembly:
subq $0x28, %rsp
callq 0x3050
movq %rax, 0x20(%rsp)
callq 0x4f50
callq 0x3050
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6bf0
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x6bc0
movq %rax, 0x10(%rsp)
movq 0xf459(%rip), %rdi      # 0x14fd0
leaq 0x955f(%rip), %rsi      # 0xf0dd
callq 0x3310
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6c40
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x35e0
movq %rax, %rdi
leaq 0x954d(%rip), %rsi      # 0xf0f4
callq 0x3310
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iannisdezwart[P]forcefield-visualiser/./lib/linear_algebra.hpp
// Function: Vector<2, double>::length()
double length()
		{
			number_type square_sum = 0;

			for (int i = 0; i < size; i++) {
				square_sum += pow(values[i], 2);
			}

			return sqrt(square_sum);
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x2, 0x14(%rsp)
jge 0x5c8d
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movl $0x2, %edi
callq 0x7bd0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5c54
movsd 0x18(%rsp), %xmm0
callq 0x32a0
addq $0x28, %rsp
retq
nopl (%rax)
// File: iannisdezwart[P]forcefield-visualiser/./lib/linear_algebra.hpp
// Function: Vector<2, double>::Vector(std::initializer_list<double>)
Vector(initializer_list<number_type> initial_values = {})
		{
			if (initial_values.size() > 0) {
				if (initial_values.size() != size) throw WRONG_DIMENSION;
				copy(initial_values.begin(), initial_values.end(), values);
			} else {
				for (int i = 0; i < size; i++) {
					values[i] = 0;
				}
			}
		}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7c00
cmpq $0x0, %rax
jbe 0x5ecd
leaq 0x28(%rsp), %rdi
callq 0x7c00
cmpq $0x2, %rax
je 0x5ea0
movl $0x4, %edi
callq 0x3180
movq %rax, %rdi
movl $0x0, (%rdi)
leaq 0xee29(%rip), %rsi      # 0x14cc0
xorl %eax, %eax
movl %eax, %edx
callq 0x3540
leaq 0x28(%rsp), %rdi
callq 0x7c60
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7c70
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rsi
callq 0x7c10
jmp 0x5efd
movl $0x0, 0x1c(%rsp)
cmpl $0x2, 0x1c(%rsp)
jge 0x5efb
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5ed5
jmp 0x5efd
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iannisdezwart[P]forcefield-visualiser/./lib/linear_algebra.hpp
// Function: Vector<2, double>::operator-(Vector<2, double>)
Vector<size, number_type> operator-(Vector<size, number_type> other_vector)
		{
			Vector<size, number_type> new_vector;

			for (int i = 0; i < size; i++) {
				new_vector.values[i] = values[i] - other_vector.values[i];
			}

			return new_vector;
		}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0x5e20
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x5e40
movl $0x0, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
jge 0x5fcc
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movslq 0xc(%rsp), %rax
subsd 0x28(%rsp,%rax,8), %xmm0
movslq 0xc(%rsp), %rax
movsd %xmm0, 0x38(%rsp,%rax,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5f94
movsd 0x38(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
addq $0x48, %rsp
retq
nopl (%rax)
// File: iannisdezwart[P]forcefield-visualiser/./lib/linear_algebra.hpp
// Function: Vector<2, double>::operator*(double)
Vector<size, number_type> operator*(number_type scalar)
		{
			Vector<size, number_type> new_vector;

			for (int i = 0; i < size; i++) {
				new_vector.values[i] = values[i] * scalar;
			}

			return new_vector;
		}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x5e20
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x5e40
movl $0x0, 0x14(%rsp)
cmpl $0x2, 0x14(%rsp)
jge 0x60c3
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd 0x28(%rsp), %xmm0
movslq 0x14(%rsp), %rax
movsd %xmm0, 0x38(%rsp,%rax,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x608f
movsd 0x38(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: iannisdezwart[P]forcefield-visualiser/./lib/linear_algebra.hpp
// Function: Matrix<2, 2, double>::Matrix(std::initializer_list<std::initializer_list<double>>)
Matrix(initializer_list<initializer_list<number_type>> initial_rows = {})
		{
			if (initial_rows.size() > 0) {
				if (initial_rows.size() != rows) throw WRONG_DIMENSION;

				int row = 0;

				for (auto initial_columns : initial_rows) {
					if (initial_columns.size() != columns) {
						throw WRONG_DIMENSION;
					} else {
						copy(initial_columns.begin(), initial_columns.end(), values[row]);
					}

					row++;
				}
			} else {
				for (int y = 0; y < rows; y++) {
					for (int x = 0; x < columns; x++) {
						values[y][x] = 0;
					}
				}
			}
		}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xe140
cmpq $0x0, %rax
jbe 0x6584
leaq 0x58(%rsp), %rdi
callq 0xe140
cmpq $0x2, %rax
je 0x64a4
movl $0x4, %edi
callq 0x3180
movq %rax, %rdi
movl $0x0, (%rdi)
leaq 0xe825(%rip), %rsi      # 0x14cc0
xorl %eax, %eax
movl %eax, %edx
callq 0x3540
movl $0x0, 0x4c(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0xe150
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0xe160
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
je 0x6582
movq 0x38(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x7c00
cmpq $0x2, %rax
je 0x652d
movl $0x4, %edi
callq 0x3180
movq %rax, %rdi
movl $0x0, (%rdi)
leaq 0xe79c(%rip), %rsi      # 0x14cc0
xorl %eax, %eax
movl %eax, %edx
callq 0x3540
leaq 0x20(%rsp), %rdi
callq 0x7c60
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x7c70
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movslq 0x4c(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdx
callq 0x7c10
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
movq 0x38(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
jmp 0x64d4
jmp 0x65de
movl $0x0, 0x1c(%rsp)
cmpl $0x2, 0x1c(%rsp)
jge 0x65dc
movl $0x0, 0x18(%rsp)
cmpl $0x2, 0x18(%rsp)
jge 0x65cd
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x659b
jmp 0x65cf
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x658c
jmp 0x65de
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iannisdezwart[P]forcefield-visualiser/./lib/linear_algebra.hpp
// Function: Vector<2, double> Matrix<2, 2, double>::operator*<2>(Vector<2, double>)
Vector<dimension, number_type> operator*(Vector<dimension, number_type> vector)
		{
			if (dimension != columns) throw WRONG_DIMENSION;

			Vector<dimension> output_vector;

			for (int i = 0; i < rows; i++) {
				for (int j = 0; j < dimension; j++) {
					output_vector[i] += values[i][j] * vector[j];
				}
			}

			return output_vector;
		}

// Assembly:
subq $0x58, %rsp
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x5e20
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x5e40
movl $0x0, 0x1c(%rsp)
cmpl $0x2, 0x1c(%rsp)
jge 0x68df
movl $0x0, 0x18(%rsp)
cmpl $0x2, 0x18(%rsp)
jge 0x68cd
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
movl 0x18(%rsp), %esi
leaq 0x38(%rsp), %rdi
callq 0x6240
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x1c(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0x6240
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x6858
jmp 0x68cf
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x6845
movsd 0x48(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
addq $0x58, %rsp
retq
// File: iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/image_info.hpp
// Function: png::image_info png::make_image_info<png::basic_rgb_pixel<unsigned char>>()
image_info
    make_image_info()
    {
        typedef pixel_traits< pixel > traits;
        image_info info;
        info.set_color_type(traits::get_color_type());
        info.set_bit_depth(traits::get_bit_depth());
        return info;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movb $0x0, 0x2f(%rsp)
callq 0x8900
callq 0x8990
movl %eax, 0x18(%rsp)
jmp 0x882b
movl 0x18(%rsp), %esi
movq 0x8(%rsp), %rdi
callq 0x8970
jmp 0x883b
callq 0x89c0
movl %eax, 0x4(%rsp)
jmp 0x8846
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
callq 0x89a0
jmp 0x8856
movb $0x1, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x8888
jmp 0x887e
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x6cf0
jmp 0x8892
movq 0x8(%rsp), %rdi
callq 0x6cf0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x3590
nopl (%rax)
// File: iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/pixel_buffer.hpp
// Function: png::basic_pixel_buffer<png::basic_rgb_pixel<unsigned char>, std::vector<png::basic_rgb_pixel<unsigned char>, std::allocator<png::basic_rgb_pixel<unsigned char>>>, png::row_traits<std::vector<png::basic_rgb_pixel<unsigned char>, std::allocator<png::basic_rgb_pixel<unsigned char>>>>>::resize(unsigned int, unsigned int)
void resize(uint_32 width, uint_32 height)
        {
            m_width = width;
            m_height = height;
            m_rows.resize(height);
            for (typename row_vec::iterator r = m_rows.begin();
                 r != m_rows.end();
                 ++r)
            {
                r->resize(width);
            }
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rdi)
addq $0x8, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x8cc0
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x8d60
movq %rax, 0x10(%rsp)
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x8dd0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8d90
testb $0x1, %al
jne 0x8c4f
jmp 0x8c73
leaq 0x10(%rsp), %rdi
callq 0x8e00
movq %rax, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x8e10
leaq 0x10(%rsp), %rdi
callq 0x8eb0
jmp 0x8c28
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/image.hpp
// Function: png::image<png::basic_rgb_pixel<unsigned char>, png::pixel_buffer<png::basic_rgb_pixel<unsigned char>>>::write(char const*)
void write(char const* filename)
        {
            std::ofstream stream(filename, std::ios::binary);
            if (!stream.is_open())
            {
                throw std_error(filename);
            }
            stream.exceptions(std::ios::badbit);
            write_stream(stream);
        }

// Assembly:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq 0x270(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x268(%rsp), %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x4, %edx
callq 0x3370
movq 0x28(%rsp), %rdi
callq 0x3280
movb %al, 0x35(%rsp)
jmp 0xaae0
movb 0x35(%rsp), %al
testb $0x1, %al
jne 0xabc8
jmp 0xaaee
movb $0x1, 0x36(%rsp)
movl $0x10, %edi
callq 0x3180
movq %rax, 0x8(%rsp)
movq 0x268(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x35b0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x6b00
jmp 0xab34
callq 0x3040
movq 0x8(%rsp), %rdi
movl (%rax), %edx
leaq 0x38(%rsp), %rsi
callq 0xac20
jmp 0xab4c
movq 0x8(%rsp), %rdi
movb $0x0, 0x36(%rsp)
leaq 0xa1b3(%rip), %rsi      # 0x14d10
leaq 0x1cc(%rip), %rdx       # 0xad30
callq 0x3540
jmp 0xac19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xac05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xaba9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3200
leaq 0x37(%rsp), %rdi
callq 0x3360
testb $0x1, 0x36(%rsp)
jne 0xabbc
jmp 0xabc6
movq 0x8(%rsp), %rdi
callq 0x3260
jmp 0xac05
movq 0x68(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x68(%rsp,%rax), %rdi
movl $0x1, %esi
callq 0x30d0
jmp 0xabe2
movq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xad40
jmp 0xabf3
leaq 0x68(%rsp), %rdi
callq 0x3470
addq $0x278, %rsp            # imm = 0x278
retq
leaq 0x68(%rsp), %rdi
callq 0x3470
movq 0x60(%rsp), %rdi
callq 0x3590
nopl (%rax)
// File: iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/writer.hpp
// Function: png::writer<std::basic_ofstream<char, std::char_traits<char>>>::write_data(png_struct_def*, unsigned char*, unsigned long)
static void write_data(png_struct* png, byte* data, png_size_t length)
        {
            io_base* io = static_cast< io_base* >(png_get_error_ptr(png));
            writer* wr = static_cast< writer* >(io);
            wr->reset_error();
            ostream* stream = reinterpret_cast< ostream* >(png_get_io_ptr(png));
            try
            {
                stream->write(reinterpret_cast< char* >(data), length);
                if (!stream->good())
                {
                    wr->set_error("ostream::write() failed");
                }
            }
            catch (std::exception const& error)
            {
                wr->set_error(error.what());
            }
            catch (...)
            {
                assert(!"caught something wrong");
                wr->set_error("write_data: caught something wrong");
            }
            if (wr->is_error())
            {
                wr->raise_error();
            }
        }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0x3600
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xbd00
movq 0x50(%rsp), %rdi
callq 0x3300
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x3410
jmp 0xb81b
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3510
movb %al, 0xf(%rsp)
jmp 0xb835
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xb8f4
jmp 0xb843
movq 0x30(%rsp), %rdi
leaq 0x3960(%rip), %rsi      # 0xf1af
callq 0xbb90
jmp 0xb856
jmp 0xb8f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xb8cb
movq 0x20(%rsp), %rdi
callq 0x3130
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xbb90
jmp 0xb8aa
callq 0x34e0
movq 0x30(%rsp), %rdi
callq 0xbd20
testb $0x1, %al
jne 0xb8bf
jmp 0xb90d
movq 0x30(%rsp), %rdi
callq 0xbbf0
jmp 0xb90d
movq 0x20(%rsp), %rdi
callq 0x3130
leaq 0x38eb(%rip), %rdi      # 0xf1c7
leaq 0x38fe(%rip), %rsi      # 0xf1e1
movl $0x9e, %edx
leaq 0x390f(%rip), %rcx      # 0xf1fe
callq 0x3210
jmp 0xb8af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x34e0
jmp 0xb90b
jmp 0xb912
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x3590
movq %rax, %rdi
callq 0x6de0
nopw %cs:(%rax,%rax)
nop
// File: iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/writer.hpp
// Function: png::writer<std::basic_ofstream<char, std::char_traits<char>>>::flush_data(png_struct_def*)
static void flush_data(png_struct* png)
        {
            io_base* io = static_cast< io_base* >(png_get_error_ptr(png));
            writer* wr = static_cast< writer* >(io);
            wr->reset_error();
            ostream* stream = reinterpret_cast< ostream* >(png_get_io_ptr(png));
            try
            {
                stream->flush();
                if (!stream->good())
                {
                    wr->set_error("ostream::flush() failed");
                }
            }
            catch (std::exception const& error)
            {
                wr->set_error(error.what());
            }
            catch (...)
            {
                assert(!"caught something wrong");
                wr->set_error("flush_data: caught something wrong");
            }
            if (wr->is_error())
            {
                wr->raise_error();
            }
        }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x3600
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xbd00
movq 0x40(%rsp), %rdi
callq 0x3300
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3220
jmp 0xb977
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3510
movb %al, 0xf(%rsp)
jmp 0xb991
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xba50
jmp 0xb99f
movq 0x30(%rsp), %rdi
leaq 0x38da(%rip), %rsi      # 0xf285
callq 0xbb90
jmp 0xb9b2
jmp 0xba50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0xba27
movq 0x20(%rsp), %rdi
callq 0x3130
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xbb90
jmp 0xba06
callq 0x34e0
movq 0x30(%rsp), %rdi
callq 0xbd20
testb $0x1, %al
jne 0xba1b
jmp 0xba69
movq 0x30(%rsp), %rdi
callq 0xbbf0
jmp 0xba69
movq 0x20(%rsp), %rdi
callq 0x3130
leaq 0x378f(%rip), %rdi      # 0xf1c7
leaq 0x37a2(%rip), %rsi      # 0xf1e1
movl $0xbb, %edx
leaq 0x3852(%rip), %rcx      # 0xf29d
callq 0x3210
jmp 0xba0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x34e0
jmp 0xba67
jmp 0xba6e
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x3590
movq %rax, %rdi
callq 0x6de0
// File: iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/info.hpp
// Function: png::info::sync_ihdr() const
void sync_ihdr(void) const
        {
            png_set_IHDR(m_png,
                         m_info,
                         m_width,
                         m_height,
                         m_bit_depth,
                         m_color_type,
                         m_interlace_type,
                         m_compression_type,
                         m_filter_type);
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movl 0x18(%rax), %edx
movl 0x1c(%rax), %ecx
movl 0x20(%rax), %r8d
movl 0x24(%rax), %r9d
movl 0x28(%rax), %r11d
movl 0x2c(%rax), %r10d
movl 0x30(%rax), %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x34f0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: rilutham[P]gotojakarta/go-to-jakarta.cpp
// Function: PathSearchNode::GetSuccessors(AStarSearch<PathSearchNode>*, PathSearchNode*)
bool PathSearchNode::GetSuccessors( AStarSearch<PathSearchNode> *astarsearch, PathSearchNode *parent_node )
{
  PathSearchNode NewNode;
  for(int c=0; c<MAX_CITIES; c++)
  {
    if(WestJavaMap[city][c] < 0) continue;
    NewNode = PathSearchNode((ENUM_CITIES)c);
    astarsearch->AddSuccessor( NewNode );
  }
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x30d0
movl $0x0, -0x20(%rbp)
cmpl $0x15, -0x20(%rbp)
jge 0x2681
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x8aef(%rip), %rax      # 0xb130
imulq $0x54, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x2657
jmp 0x2676
movl -0x20(%rbp), %esi
leaq -0x24(%rbp), %rdi
callq 0x30f0
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x3110
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x262c
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)