LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/querymain.cc
// Function: runQueries(std::basic_ifstream<char, std::char_traits<char>>&)
void runQueries(ifstream& infile)
{
	// infile is an ifstream that is the file we want to query
    TextQuery tq(infile);  // store the file and build the query map
    // iterate with the user: prompt for a word to find and print results
    while (true) {
        cout << "enter word to look for, or q to quit: ";
        string s;
        // stop if we hit end-of-file on the input or if a 'q' is entered
        if (!(cin >> s) || s == "q") break;
		// run the query and print the results
        print(cout, tq.query(s)) << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2dc0
jmp 0x24ce
movq 0xaaf3(%rip), %rdi      # 0xcfc8
leaq 0x5b28(%rip), %rsi      # 0x8004
callq 0x21b0
jmp 0x24e3
leaq -0x78(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x2270
movq -0xd0(%rbp), %rsi
movq 0xaad7(%rip), %rdi      # 0xcfd8
callq 0x2250
movq %rax, -0xc8(%rbp)
jmp 0x250f
movq -0xc8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x20d0
movb %al, -0xd1(%rbp)
jmp 0x252d
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x255d
jmp 0x2539
leaq 0x5aeb(%rip), %rsi      # 0x802b
leaq -0x78(%rbp), %rdi
callq 0x2770
movb %al, -0xd2(%rbp)
jmp 0x2551
movb -0xd2(%rbp), %al
testb $0x1, %al
jne 0x255d
jmp 0x2588
movl $0x3, -0x7c(%rbp)
jmp 0x25e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2630
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2613
leaq -0xc0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x31a0
jmp 0x259e
movq 0xaa23(%rip), %rdi      # 0xcfc8
leaq -0xc0(%rbp), %rsi
callq 0x34b0
movq %rax, -0xe0(%rbp)
jmp 0x25ba
movq -0xe0(%rbp), %rdi
movq 0xa9e8(%rip), %rsi      # 0xcfb0
callq 0x21f0
jmp 0x25cf
leaq -0xc0(%rbp), %rdi
callq 0x27a0
movl $0x0, -0x7c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2110
movl -0x7c(%rbp), %eax
testl %eax, %eax
je 0x25f6
jmp 0x25f4
jmp 0x261e
jmp 0x24cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x27a0
leaq -0x78(%rbp), %rdi
callq 0x2110
jmp 0x2630
leaq -0x48(%rbp), %rdi
callq 0x27e0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x27e0
movq -0x50(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/querymain.cc
// Function: main
int main(int argc, char **argv)
{
    // open the file from which user will query words
    ifstream infile;
	// open returns void, so we use the comma operator XREF(commaOp)
	// to check the state of infile after the open
    if (argc < 2 || !(infile.open(argv[1]), infile)) {
        cerr << "No input file!" << endl;
        return EXIT_FAILURE;
    }
	runQueries(infile);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x2210
cmpl $0x2, -0x8(%rbp)
jl 0x26c2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x2130
jmp 0x2696
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x20d0
movb %al, -0x229(%rbp)
jmp 0x26b6
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x26c2
jmp 0x2726
movq 0xa927(%rip), %rdi      # 0xcff0
leaq 0x595d(%rip), %rsi      # 0x802d
callq 0x21b0
movq %rax, -0x238(%rbp)
jmp 0x26de
movq -0x238(%rbp), %rdi
movq 0xa8c4(%rip), %rsi      # 0xcfb0
callq 0x21f0
jmp 0x26f3
movl $0x1, -0x4(%rbp)
movl $0x1, -0x228(%rbp)
jmp 0x2745
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x2070
jmp 0x275d
leaq -0x218(%rbp), %rdi
callq 0x24b0
jmp 0x2734
movl $0x0, -0x4(%rbp)
movl $0x1, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x2070
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: errantlinguist[P]Forecast/src/main.cpp
// Function: readJsonStream(std::istream&)
static int readJsonStream(std::istream& input)
{
	int result(EXIT_FAILURE);

	console_weather::ForecastStreamReader forecastReader(DEFAULT_MEASUREMENT_UNITS, DEFAULT_READ_BUFFER_SIZE);
	try {
		std::unique_ptr<forecast_io::Forecast> pForecast = forecastReader.read(input);
		if (pForecast == nullptr)
		{
			std::cerr << DEFAULT_URL_GETTER_ERROR_MESSAGE << std::endl;
			result = common::getSysExitCode(common::SysExit::IO_DEVICE_ERROR);
		} else
		{
			print(*pForecast);
			result = EXIT_SUCCESS;
		}
	} catch(const json::ParseError& e)
	{
		std::cerr << createJsonParseErrorMessage(e) << std::endl;
	}

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x39460
movq -0x70(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x39500
jmp 0xd360
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xde70
testb $0x1, %al
jne 0xd376
jmp 0xd450
movq 0x8fc43(%rip), %rdi     # 0x9cfc0
leaq 0x58ea0(%rip), %rsi     # 0x66224
callq 0xa4a0
movq %rax, -0x78(%rbp)
jmp 0xd38f
movq -0x78(%rbp), %rdi
movq 0x8fc16(%rip), %rsi     # 0x9cfb0
callq 0xa800
jmp 0xd3a1
movl $0x4a, %edi
callq 0xde60
movl %eax, -0xc(%rbp)
jmp 0xd477
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd3d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xded0
movl -0x3c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xd4be
movq -0x38(%rbp), %rdi
callq 0xa080
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xd9f0
jmp 0xd402
movq 0x8fbb7(%rip), %rdi     # 0x9cfc0
leaq -0x68(%rbp), %rsi
callq 0xa240
movq %rax, -0x80(%rbp)
jmp 0xd418
movq -0x80(%rbp), %rdi
movq 0x8fb8d(%rip), %rsi     # 0x9cfb0
callq 0xa800
jmp 0xd42a
leaq -0x68(%rbp), %rdi
callq 0xa978
callq 0xa630
jmp 0xd43a
jmp 0xd43c
leaq -0x28(%rbp), %rdi
callq 0xdf50
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xdea0
movq %rax, -0x88(%rbp)
jmp 0xd462
movq -0x88(%rbp), %rdi
callq 0xd960
jmp 0xd470
movl $0x0, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xded0
jmp 0xd43c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd4b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa978
jmp 0xd4b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd4be
callq 0xa630
jmp 0xd4bc
jmp 0xd4be
leaq -0x28(%rbp), %rdi
callq 0xdf50
movq -0x38(%rbp), %rdi
callq 0xa520
movq %rax, %rdi
callq 0xdf40
nopl (%rax,%rax)
// File: errantlinguist[P]Forecast/src/main.cpp
// Function: createJsonParseErrorMessage[abi:cxx11](std::exception const&)
static std::string createJsonParseErrorMessage(const std::exception& e)
{
	std::stringstream errorMessage(std::stringstream::out);
	errorMessage << "There was an error parsing the server response as JSON: ";
	errorMessage << e.what() << std::endl;
	return errorMessage.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
movl $0x10, %esi
callq 0xa360
leaq -0x188(%rbp), %rdi
leaq 0x58820(%rip), %rsi     # 0x66253
callq 0xa4a0
jmp 0xda3a
leaq -0x188(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x1c8(%rbp), %rdi
movq %rax, %rsi
callq 0xa4a0
movq %rax, -0x1c0(%rbp)
jmp 0xda6d
movq -0x1c0(%rbp), %rdi
movq 0x8f535(%rip), %rsi     # 0x9cfb0
callq 0xa800
jmp 0xda82
movq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xa590
jmp 0xda97
leaq -0x198(%rbp), %rdi
callq 0xa2c0
movq -0x1b0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa2c0
movq -0x1a0(%rbp), %rdi
callq 0xa520
nopl (%rax)
// File: errantlinguist[P]Forecast/src/main.cpp
// Function: printCurlErrorMessage(char const* const&)
static void printCurlErrorMessage(const char* const& pCurlErrorMessage)
{
	if (std::strcmp(pCurlErrorMessage, "") == 0)
	{
		std::cerr << DEFAULT_URL_GETTER_ERROR_MESSAGE << std::endl;
	} else
	{
		std::cerr << "An error occurred while getting the given URL: " << pCurlErrorMessage << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x5895f(%rip), %rsi     # 0x66459
callq 0xa670
cmpl $0x0, %eax
jne 0xdb28
movq 0x8f4b5(%rip), %rdi     # 0x9cfc0
leaq 0x58712(%rip), %rsi     # 0x66224
callq 0xa4a0
movq %rax, %rdi
movq 0x8f48f(%rip), %rsi     # 0x9cfb0
callq 0xa800
jmp 0xdb59
movq 0x8f491(%rip), %rdi     # 0x9cfc0
leaq 0x587f9(%rip), %rsi     # 0x6632f
callq 0xa4a0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0xa4a0
movq %rax, %rdi
movq 0x8f45c(%rip), %rsi     # 0x9cfb0
callq 0xa800
addq $0x10, %rsp
popq %rbp
retq
nop
// File: errantlinguist[P]Forecast/src/main.cpp
// Function: isLastResponseContentInvalid(curl::CallbackClient const&, char* const&)
static bool isLastResponseContentInvalid(const curl::CallbackClient& curlClient, char* const& pInfoBuffer)
{
	bool result(false);

	CURLcode infoGetterCode = curlClient.getInfo(CURLINFO_CONTENT_TYPE, pInfoBuffer);
	if (CURLE_OK == infoGetterCode && pInfoBuffer != NULL)
	{
		const std::string infoType(pInfoBuffer);
		std::smatch jsonMatch;
		result = (!std::regex_match(infoType, jsonMatch, VALID_CONTENT_TYPE_REGEX));
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl $0x100012, %esi         # imm = 0x100012
callq 0x3be90
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl -0x18(%rbp), %eax
jne 0xdc6b
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdc6b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xa770
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xdcb0
jmp 0xdbd3
leaq -0x39(%rbp), %rdi
callq 0xa960
leaq -0x70(%rbp), %rdi
callq 0xf8b0
jmp 0xdbe7
leaq 0x8fde2(%rip), %rdx     # 0x9d9d0
leaq -0x38(%rbp), %rdi
leaq -0x70(%rbp), %rsi
xorl %ecx, %ecx
callq 0xf8f0
movb %al, -0x81(%rbp)
jmp 0xdc05
movb -0x81(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xf950
leaq -0x38(%rbp), %rdi
callq 0xa978
jmp 0xdc6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xa960
jmp 0xdc79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xdc60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xf950
leaq -0x38(%rbp), %rdi
callq 0xa978
jmp 0xdc79
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xa520
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: errantlinguist[P]Forecast/src/common/TimeWriter.cpp
// Function: common::TimeWriter::write(tm const*, std::ostream&)
void TimeWriter::write(const struct tm* value, std::ostream& output)
{
	std::unique_ptr<char[]> pBuffer(new char[maxLength]);
	char* const rawpBuffer = pBuffer.get();
	std::strftime(rawpBuffer, maxLength, format, value);
	output << rawpBuffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x10(%rax), %rdi
callq 0xa390
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xf6a0
movq -0x48(%rbp), %rdi
callq 0xf6d0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rcx
callq 0xa6d0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa4a0
jmp 0x37f1d
leaq -0x20(%rbp), %rdi
callq 0xf4b0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xf4b0
movq -0x30(%rbp), %rdi
callq 0xa520
nopw (%rax,%rax)
// File: errantlinguist[P]Forecast/src/common/to_string.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> common::to_quoted_string<char>(char const&)
std::string to_quoted_string(const char& value)
{
	std::stringstream ss(std::stringstream::out);

	ss << CHAR_VALUE_DELIMITER;
	ss << value;
	ss << CHAR_VALUE_DELIMITER;

	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
movl $0x10, %esi
callq 0xa360
leaq -0x188(%rbp), %rdi
movl $0x27, %esi
callq 0xa550
jmp 0x37ff8
leaq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
callq 0xa550
jmp 0x3800d
leaq -0x188(%rbp), %rdi
movl $0x27, %esi
callq 0xa550
jmp 0x38020
movq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xa590
jmp 0x38035
leaq -0x198(%rbp), %rdi
callq 0xa2c0
movq -0x1b0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa2c0
movq -0x1a0(%rbp), %rdi
callq 0xa520
nopl (%rax,%rax)
// File: errantlinguist[P]Forecast/src/common/to_string.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> common::to_quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string to_quoted_string(const std::string& value)
{
	std::stringstream ss(std::stringstream::out);

	ss << STRING_VALUE_DELIMITER;
	ss << value;
	ss << STRING_VALUE_DELIMITER;

	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
movl $0x10, %esi
callq 0xa360
leaq -0x188(%rbp), %rdi
movl $0x22, %esi
callq 0xa550
jmp 0x380c8
leaq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa240
jmp 0x380da
leaq -0x188(%rbp), %rdi
movl $0x22, %esi
callq 0xa550
jmp 0x380ed
movq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xa590
jmp 0x38102
leaq -0x198(%rbp), %rdi
callq 0xa2c0
movq -0x1b0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa2c0
movq -0x1a0(%rbp), %rdi
callq 0xa520
nopl (%rax,%rax)
// File: errantlinguist[P]Forecast/src/console_weather/ForecastServiceClient.cpp
// Function: console_weather::parseJson(char*, unsigned long, unsigned long, void*)
static size_t parseJson(char* readBuffer, size_t size, size_t nmemb,
                        void* pUserData)
{
    size_t result(0);
    if(pUserData)
    {
        json::TokenerParser* const pTokenerParser =
            static_cast<json::TokenerParser*>(pUserData);
        // Calculate the amount of bytes to be parsed
        result = size * nmemb;
        // Check that the size does not overflow as an int type
        if(result <= MAX_PARSER_INPUT_SIZE)
        {
			const int inputSize = static_cast<int>(result);
            pTokenerParser->parse(readBuffer, inputSize);
        }
        else
        {
            throw std::out_of_range("Amount of bytes to read cannot be stored as an int.");
        }

    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x38575
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
ja 0x38523
movq -0x28(%rbp), %rax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %edx
leaq -0x8(%rbp), %rsi
callq 0x64780
jmp 0x38573
movl $0x10, %edi
callq 0xa2d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x2ec88(%rip), %rsi     # 0x671c6
callq 0xa1f0
jmp 0x38545
movq -0x50(%rbp), %rdi
movq 0x64a08(%rip), %rsi     # 0x9cf58
movq 0x64a39(%rip), %rdx     # 0x9cf90
callq 0xa500
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xa6c0
jmp 0x3857f
jmp 0x38575
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xa520
nopl (%rax,%rax)
// File: errantlinguist[P]Forecast/src/console_weather/writers/AlertConsoleWriter.cpp
// Function: console_weather::writers::AlertConsoleWriter::write(forecast_io::Alert const&, std::ostream&)
void AlertConsoleWriter::write(const forecast_io::Alert& value, std::ostream& output)
{
	output << value.getTitle() << '\n';
	output << headerSeparator << '\n';
	output << value.getDescription();
	output << "\nFor more information see " << value.getUri() << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x399b0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0xa240
movq %rax, -0x90(%rbp)
jmp 0x3986d
movq -0x90(%rbp), %rdi
movl $0xa, %esi
callq 0xa550
jmp 0x39880
leaq -0x38(%rbp), %rdi
callq 0xa978
movq -0xa8(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0xa240
movq %rax, %rdi
movl $0xa, %esi
callq 0xa550
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x399e0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xa240
jmp 0x398da
leaq -0x68(%rbp), %rdi
callq 0xa978
movq -0x18(%rbp), %rdi
leaq 0x2d9f6(%rip), %rsi     # 0x672e4
callq 0xa4a0
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x39a10
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0xa240
movq %rax, -0xc0(%rbp)
jmp 0x3992d
movq -0xc0(%rbp), %rdi
movl $0xa, %esi
callq 0xa550
jmp 0x39940
leaq -0x88(%rbp), %rdi
callq 0xa978
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa978
jmp 0x3999b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa978
jmp 0x3999b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xa978
movq -0x40(%rbp), %rdi
callq 0xa520
nopw %cs:(%rax,%rax)
nop
// File: errantlinguist[P]Forecast/src/console_weather/writers/SynchronicDataPointConsoleWriter.cpp
// Function: console_weather::writers::SynchronicDataPointConsoleWriter::write(forecast_io::SynchronicDataPoint const&, std::ostream&)
void SynchronicDataPointConsoleWriter::write(const forecast_io::SynchronicDataPoint& value, std::ostream& output)
{
	const forecast_io::SingleDataPoint& baseDataPoint = value.getBaseDataPoint();
	write(baseDataPoint, output);
	const math::RelativePosition<double, double>& nearestStorm = value.getNearestStorm();
	output << nearestStormSectionHeader << '\n';
	writers::write(nearestStorm, output);
	output << headerRowSeparator << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b620
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3af10
movq -0x10(%rbp), %rdi
callq 0x3b630
movq -0x40(%rbp), %rsi
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x38, %rsi
callq 0xa240
movq %rax, %rdi
movl $0xa, %esi
callq 0xa550
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b010
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x18, %rsi
callq 0xa240
movq %rax, %rdi
movl $0xa, %esi
callq 0xa550
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: errantlinguist[P]Forecast/src/console_weather/writers/SynchronicDataPointConsoleWriter.cpp
// Function: console_weather::writers::SynchronicDataPointConsoleWriter::write(forecast_io::SingleDataPoint const&, std::ostream&)
void SynchronicDataPointConsoleWriter::write(const forecast_io::SingleDataPoint& value, std::ostream& output)
{
	const forecast_io::DataPoint& baseDataPoint = value.getBaseDataPoint();
	write(baseDataPoint, output);
	output << "Temperature: " << value.getTemperature() << DEGREE_SYMBOL << ' ' << TEMPERATURE_UNITS << '\n';
	output << "Apparent temperature: " << value.getApparentTemperature() << DEGREE_SYMBOL << ' ' << TEMPERATURE_UNITS << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b7d0
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3b0c0
movq -0x18(%rbp), %rdi
leaq 0x2c536(%rip), %rsi     # 0x6748b
callq 0xa4a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b7e0
movq -0x30(%rbp), %rdi
callq 0xa680
movq %rax, %rdi
leaq 0x2c4da(%rip), %rsi     # 0x67454
callq 0xa4a0
movq %rax, %rdi
movl $0x20, %esi
callq 0xa550
movq %rax, %rdi
movl $0x46, %esi
callq 0xa550
movq %rax, %rdi
movl $0xa, %esi
callq 0xa550
movq -0x18(%rbp), %rdi
leaq 0x2c4e8(%rip), %rsi     # 0x67499
callq 0xa4a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b800
movq -0x28(%rbp), %rdi
callq 0xa680
movq %rax, %rdi
leaq 0x2c47e(%rip), %rsi     # 0x67454
callq 0xa4a0
movq %rax, %rdi
movl $0x20, %esi
callq 0xa550
movq %rax, %rdi
movl $0x46, %esi
callq 0xa550
movq %rax, %rdi
movl $0xa, %esi
callq 0xa550
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: errantlinguist[P]Forecast/src/console_weather/writers/SynchronicDataPointConsoleWriter.cpp
// Function: console_weather::writers::write(forecast_io::Precipitation const&, std::ostream&)
static void write(const forecast_io::Precipitation& value, std::ostream& output)
{
	output << "Intensity: " << value.getIntensity() << '\n';
	output << "Probability: " << value.getProbability() << '\n';
	output << "Type: ";
	const std::string& type = value.getType();
	if (type.empty())
	{
		output << "(none)";
	} else
	{
		output << type;
	}
	output << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2c035(%rip), %rsi     # 0x674b0
callq 0xa4a0
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b820
movq -0x58(%rbp), %rdi
callq 0xa680
movq %rax, %rdi
movl $0xa, %esi
callq 0xa550
movq -0x10(%rbp), %rdi
leaq 0x2c00e(%rip), %rsi     # 0x674bc
callq 0xa4a0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b840
movq -0x50(%rbp), %rdi
callq 0xa680
movq %rax, %rdi
movl $0xa, %esi
callq 0xa550
movq -0x10(%rbp), %rdi
leaq 0x2bfe9(%rip), %rsi     # 0x674ca
callq 0xa4a0
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3b860
leaq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa200
testb $0x1, %al
jne 0x3b50a
jmp 0x3b535
movq -0x10(%rbp), %rdi
leaq 0x2bfbc(%rip), %rsi     # 0x674d1
callq 0xa4a0
jmp 0x3b51c
jmp 0x3b546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa978
jmp 0x3b565
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa240
jmp 0x3b544
jmp 0x3b546
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0xa550
jmp 0x3b556
leaq -0x38(%rbp), %rdi
callq 0xa978
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xa520
nop
// File: errantlinguist[P]Forecast/src/console_weather/writers/console_writing.cpp
// Function: console_weather::writers::createPaddedHeader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, int)
std::string createPaddedHeader(const std::string& prefix,
		const std::stringstream::char_type paddingSymbol, int resultLength)
{
	const int paddingLength = getPaddingLength(prefix, resultLength);

	std::stringstream ss(std::stringstream::out);
	ss << prefix;
	ss << std::setfill(paddingSymbol) << std::setw(paddingLength) << "";
	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1d0(%rbp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x3ba60
movl %eax, -0x1c(%rbp)
leaq -0x1a8(%rbp), %rdi
movl $0x10, %esi
callq 0xa360
leaq -0x198(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa240
jmp 0x3b96e
leaq -0x198(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movsbl -0x11(%rbp), %edi
callq 0x3bc20
movb %al, -0x1d1(%rbp)
jmp 0x3b98d
movq -0x1e0(%rbp), %rdi
movb -0x1d1(%rbp), %al
movb %al, -0x1b5(%rbp)
movzbl -0x1b5(%rbp), %esi
callq 0xa600
movq %rax, -0x1e8(%rbp)
jmp 0x3b9b5
movl -0x1c(%rbp), %edi
callq 0x3bc40
movl %eax, -0x1ec(%rbp)
jmp 0x3b9c5
movq -0x1e8(%rbp), %rdi
movl -0x1ec(%rbp), %eax
movl %eax, -0x1bc(%rbp)
movl -0x1bc(%rbp), %esi
callq 0xa410
movq %rax, -0x1f8(%rbp)
jmp 0x3b9ec
movq -0x1f8(%rbp), %rdi
leaq 0x2aa5f(%rip), %rsi     # 0x66459
callq 0xa4a0
jmp 0x3ba01
movq -0x1d0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xa590
jmp 0x3ba16
leaq -0x1a8(%rbp), %rdi
callq 0xa2c0
movq -0x1c8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0xa2c0
movq -0x1b0(%rbp), %rdi
callq 0xa520
nopl (%rax)
// File: errantlinguist[P]Forecast/src/console_weather/writers/console_writing.cpp
// Function: console_weather::writers::getPaddingLength(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
static int getPaddingLength(const std::string& prefix, int resultLength)
{
	const size_t prefixLength = prefix.size();
	assert(prefixLength <= MAX_PREFIX_LENGTH);
	const int castPrefixLength = static_cast<int>(prefixLength);
	assert(castPrefixLength <= resultLength);
	return resultLength - castPrefixLength;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa230
movq %rax, -0x18(%rbp)
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
ja 0x3ba88
jmp 0x3baa7
leaq 0x2ba6a(%rip), %rdi     # 0x674f9
leaq 0x2ba85(%rip), %rsi     # 0x6751b
movl $0x11, %edx
leaq 0x2baa9(%rip), %rcx     # 0x6754b
callq 0xa160
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x3bab8
jmp 0x3bad7
leaq 0x2bad5(%rip), %rdi     # 0x67594
leaq 0x2ba55(%rip), %rsi     # 0x6751b
movl $0x13, %edx
leaq 0x2ba79(%rip), %rcx     # 0x6754b
callq 0xa160
movl -0xc(%rbp), %eax
subl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: errantlinguist[P]Forecast/src/curl/CallbackClient.cpp
// Function: curl::CallbackClient::CallbackClient(char* const&)
CallbackClient::CallbackClient(char* const& pErrorBuffer) : pCurlHandle(curl_easy_init()), pErrorBuffer(pErrorBuffer), pHeaders(NULL)
{
	if (pCurlHandle)
	{
		CURLcode setupResult = setupHandle(pCurlHandle);
		if (CURLE_OK != setupResult)
		{
			throw setupResult;
		}
	} else
	{
		throw CURLE_FAILED_INIT;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x5f661(%rip), %rcx     # 0x9b2e0
addq $0x10, %rcx
movq %rcx, (%rax)
callq 0xa7a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
cmpq $0x0, 0x8(%rax)
je 0x3bceb
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x3bd20
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
je 0x3bce9
movl $0x4, %edi
callq 0xa2d0
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, (%rdi)
leaq 0x5f2c8(%rip), %rsi     # 0x9afa8
xorl %eax, %eax
movl %eax, %edx
callq 0xa500
jmp 0x3bd0e
movl $0x4, %edi
callq 0xa2d0
movq %rax, %rdi
movl $0x2, (%rdi)
leaq 0x5f2a3(%rip), %rsi     # 0x9afa8
xorl %eax, %eax
movl %eax, %edx
callq 0xa500
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: errantlinguist[P]Forecast/src/curl/CallbackClient.cpp
// Function: curl::CallbackClient::setupHandle(void*&)
CURLcode CallbackClient::setupHandle(CURL*& pCurlHandle)
{
	CURLcode result(curl_easy_setopt(pCurlHandle, CURLOPT_ERRORBUFFER, pErrorBuffer));
	if (CURLE_OK == result)
	{
		result = curl_easy_setopt(pCurlHandle, CURLOPT_NOPROGRESS, 1L);
		if (CURLE_OK == result)
		{
			result = curl_easy_setopt(pCurlHandle, CURLOPT_FOLLOWLOCATION, 1L);
		}
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
movq 0x10(%rax), %rax
movq (%rax), %rdx
movl $0x271a, %esi           # imm = 0x271A
movb $0x0, %al
callq 0xa6a0
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x3bd97
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2b, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0xa6a0
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x3bd95
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x34, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0xa6a0
movl %eax, -0x14(%rbp)
jmp 0x3bd97
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: errantlinguist[P]Forecast/src/curl/CallbackClient.cpp
// Function: curl::CallbackClient::~CallbackClient()
CallbackClient::~CallbackClient()
{
	// Clean up resources for cURL library
	curl_easy_cleanup(pCurlHandle);
	if (pHeaders != NULL)
	{
		curl_slist_free_all(pHeaders);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x5f535(%rip), %rcx     # 0x9b2f0
movq %rcx, (%rax)
movq 0x8(%rax), %rdi
callq 0xa110
jmp 0x3bdc9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3bde5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xa6e0
jmp 0x3bde3
jmp 0x3bde5
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xdf40
nopw %cs:(%rax,%rax)
// File: errantlinguist[P]Forecast/src/curl/CallbackClient.cpp
// Function: curl::CallbackClient::addHeader(char const* const&)
bool CallbackClient::addHeader(const char* const& pHeader)
{
	bool result(false);

	curl_slist* pNewHeaders = curl_slist_append(pHeaders, pHeader);
	if (pNewHeaders != NULL)
	{
		pHeaders = pNewHeaders;
		result = true;
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x11(%rbp)
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xa530
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3be77
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movb $0x1, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: errantlinguist[P]Forecast/src/curl/CallbackClient.cpp
// Function: curl::CallbackClient::read(char const*, unsigned long (*)(char*, unsigned long, unsigned long, void*), void*, long)
CURLcode CallbackClient::read(const char* url, WriteFunction* pCallback, void* pUserData,
		long timeout)
{
	CURLcode result(CURLE_FAILED_INIT);

	if (
			CURLE_OK == (result = curl_easy_setopt(pCurlHandle, CURLOPT_WRITEFUNCTION, pCallback))
			&& CURLE_OK == (result = curl_easy_setopt(pCurlHandle, CURLOPT_WRITEDATA, pUserData))
			&& CURLE_OK == (result = curl_easy_setopt(pCurlHandle, CURLOPT_TIMEOUT, timeout))
			&& CURLE_OK == (result = curl_easy_setopt(pCurlHandle, CURLOPT_URL, url)))
	{
		if (pHeaders != NULL)
		{
			result = curl_easy_setopt(pCurlHandle, CURLOPT_HTTPHEADER, pHeaders);
			if (CURLE_OK == result)
			{
				result = curl_easy_perform(pCurlHandle);
			}
		}
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x2, -0x2c(%rbp)
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rdx
movl $0x4e2b, %esi           # imm = 0x4E2B
movb $0x0, %al
callq 0xa6a0
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3bfbc
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rdx
movl $0x2711, %esi           # imm = 0x2711
movb $0x0, %al
callq 0xa6a0
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3bfbc
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rdx
movl $0xd, %esi
movb $0x0, %al
callq 0xa6a0
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3bfbc
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rdx
movl $0x2712, %esi           # imm = 0x2712
movb $0x0, %al
callq 0xa6a0
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3bfbc
movq -0x38(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3bfba
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rax), %rdx
movl $0x2727, %esi           # imm = 0x2727
movb $0x0, %al
callq 0xa6a0
movl %eax, -0x2c(%rbp)
xorl %eax, %eax
cmpl -0x2c(%rbp), %eax
jne 0x3bfb8
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa560
movl %eax, -0x2c(%rbp)
jmp 0x3bfba
jmp 0x3bfbc
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: errantlinguist[P]Forecast/src/forecast_io/Alert.cpp
// Function: forecast_io::Alert::hash() const
size_t Alert::hash() const
{
	size_t result(1U);
	static constexpr size_t prime = 31;

	static std::hash<std::string> str_hash;
	result = prime * result + (str_hash(title));
	result = prime * result + (str_hash(description));
	result = prime * result + (str_hash(uri));

	static std::hash<time_t> time_t_hash;
	result = prime * result + (time_t_hash(expiryTime));

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq $0x1, -0x10(%rbp)
imulq $0x1f, -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rsi
leaq 0x618a0(%rip), %rdi     # 0x9dc90
callq 0x3c860
movq -0x20(%rbp), %rsi
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
imulq $0x1f, -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x30, %rsi
leaq 0x61875(%rip), %rdi     # 0x9dc90
callq 0x3c860
movq -0x20(%rbp), %rsi
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
imulq $0x1f, -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x50, %rsi
leaq 0x6184a(%rip), %rdi     # 0x9dc90
callq 0x3c860
movq -0x28(%rbp), %rcx
movq %rax, %rdx
movq -0x20(%rbp), %rax
addq %rdx, %rcx
movq %rcx, -0x10(%rbp)
imulq $0x1f, -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x28(%rax), %rsi
leaq 0x61820(%rip), %rdi     # 0x9dc91
callq 0x3c8b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: errantlinguist[P]Forecast/src/forecast_io/DataOverview.cpp
// Function: forecast_io::DataOverview::dump(std::ostream&) const
std::ostream& DataOverview::dump(std::ostream& o) const
{
	o << "DataOverview[getSummary()=";
	o << common::to_quoted_string(getSummary());
	o << ", getIconName()=";
	o << common::to_quoted_string(getIconName());
	o << ']';

	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2a850(%rip), %rsi     # 0x67709
callq 0xa4a0
movq -0xb8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3b6a0
movq -0xa8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x38080
jmp 0x3cef2
movq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa240
jmp 0x3cf04
leaq -0x30(%rbp), %rdi
callq 0xa978
leaq -0x50(%rbp), %rdi
callq 0xa978
movq -0x10(%rbp), %rdi
leaq 0x2a803(%rip), %rsi     # 0x67724
callq 0xa4a0
movq -0xb8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3d130
movq -0xc0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x38080
jmp 0x3cf5d
movq -0xc8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xa240
jmp 0x3cf6f
leaq -0x80(%rbp), %rdi
callq 0xa978
leaq -0xa0(%rbp), %rdi
callq 0xa978
movq -0x10(%rbp), %rdi
movl $0x5d, %esi
callq 0xa550
movq -0x10(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3cfc2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa978
leaq -0x50(%rbp), %rdi
callq 0xa978
jmp 0x3cffc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3cff0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xa978
leaq -0xa0(%rbp), %rdi
callq 0xa978
movq -0x58(%rbp), %rdi
callq 0xa520
nopw %cs:(%rax,%rax)
// File: errantlinguist[P]Forecast/include/common/to_string.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> common::to_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, char>(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, std::pair<char, char> const&)
std::string to_string(const std::pair<L, R>& value,
		const std::pair<LD, RD>& delimiters)
{
	std::stringstream ss(std::stringstream::out);

	ss << delimiters.first << to_quoted_string(value.first)
			<< SEQUENCE_ELEMENT_SEPARATOR << to_quoted_string(value.second)
			<< delimiters.second;

	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x208(%rbp)
movq %rdi, %rax
movq %rax, -0x200(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
movl $0x10, %esi
callq 0xa360
leaq -0x190(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
callq 0xa550
movq %rax, -0x1f8(%rbp)
jmp 0x403b5
movq -0x10(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
callq 0x38080
jmp 0x403c7
movq -0x1f8(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xa240
movq %rax, -0x210(%rbp)
jmp 0x403e3
movq -0x210(%rbp), %rdi
leaq 0x5d8e7(%rip), %rsi     # 0x9dcd8
callq 0xa240
movq %rax, -0x218(%rbp)
jmp 0x403ff
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
leaq -0x1f0(%rbp), %rdi
callq 0x38080
jmp 0x40415
movq -0x218(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0xa240
movq %rax, -0x220(%rbp)
jmp 0x40431
movq -0x220(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %esi
callq 0xa550
jmp 0x40447
leaq -0x1f0(%rbp), %rdi
callq 0xa978
leaq -0x1d0(%rbp), %rdi
callq 0xa978
movq -0x208(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xa590
jmp 0x40474
leaq -0x1a0(%rbp), %rdi
callq 0xa2c0
movq -0x200(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x404e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x404d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0xa978
leaq -0x1d0(%rbp), %rdi
callq 0xa978
leaq -0x1a0(%rbp), %rdi
callq 0xa2c0
movq -0x1a8(%rbp), %rdi
callq 0xa520
nopw (%rax,%rax)
// File: errantlinguist[P]Forecast/src/forecast_io/MeasurementSystemDefaultAttributeValueMapHolder.cpp
// Function: forecast_io::MeasurementSystemDefaultAttributeValueMapHolder::findMeasurementSystem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
const math::MeasurementSystem* MeasurementSystemDefaultAttributeValueMapHolder::findMeasurementSystem(MeasurementSystemAttributeValueMap::key_type attributeValue)
{
	const math::MeasurementSystem* result(nullptr);

	const MeasurementSystemAttributeValueMap& measurementSystemAttributeValues = *getInstance();
	auto iter = measurementSystemAttributeValues.find(attributeValue);
	if (iter != measurementSystemAttributeValues.end())
	{
		const math::MeasurementSystem& measurementSystem = iter->second;
		result = &measurementSystem;
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
callq 0x41df0
movq %rax, %rdi
callq 0x41e00
movq -0x38(%rbp), %rsi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41e30
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41e90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41e60
testb $0x1, %al
jne 0x419ba
jmp 0x419d3
leaq -0x20(%rbp), %rdi
callq 0x41ec0
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: errantlinguist[P]Forecast/src/forecast_io/MeasurementSystemDefaultAttributeValueMapHolder.cpp
// Function: forecast_io::MeasurementSystemDefaultAttributeValueMapHolder::createInstance[abi:cxx11]()
std::unique_ptr<MeasurementSystemAttributeValueMap> MeasurementSystemDefaultAttributeValueMapHolder::createInstance()
{
	std::unique_ptr<MeasurementSystemAttributeValueMap> result(
			new MeasurementSystemAttributeValueMap(
					math::MeasurementSystem_COUNT));
	insertDefaultMeasurementSystems(*result);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movl $0x38, %edi
callq 0xa140
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movb $0x1, -0x1d(%rbp)
leaq -0xc(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x41ef0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %r8
movl $0x4, %esi
leaq -0xa(%rbp), %rdx
leaq -0xb(%rbp), %rcx
callq 0x41f10
jmp 0x41a3a
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movb $0x0, -0x1d(%rbp)
callq 0x41f50
leaq -0xc(%rbp), %rdi
callq 0x41f80
movq -0x48(%rbp), %rdi
callq 0x41e00
movq %rax, -0x50(%rbp)
jmp 0x41a63
movq -0x50(%rbp), %rdi
callq 0x41ae0
jmp 0x41a6e
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x41ac7
jmp 0x41abe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x41f80
testb $0x1, -0x1d(%rbp)
jne 0x41a97
jmp 0x41aa5
movq -0x38(%rbp), %rdi
movl $0x38, %esi
callq 0xa0f0
jmp 0x41ad1
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x41da0
jmp 0x41ad1
movq -0x48(%rbp), %rdi
callq 0x41da0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xa520
nopw (%rax,%rax)
// File: errantlinguist[P]Forecast/src/forecast_io/MeasurementSystemDefaultNameArrayHolder.cpp
// Function: forecast_io::MeasurementSystemDefaultNameArrayHolder::createInstance[abi:cxx11]()
std::unique_ptr<MeasurementSystemNameArray> MeasurementSystemDefaultNameArrayHolder::createInstance()
{
	std::unique_ptr<MeasurementSystemNameArray> result(
			new MeasurementSystemNameArray());
	insertDefaultMeasurementSystemNames(*result);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movl $0x80, %edi
callq 0xa140
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, 0x70(%rdi)
movaps %xmm0, 0x60(%rdi)
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x43fd0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x44020
movq -0x30(%rbp), %rdi
callq 0x39d80
movq %rax, -0x28(%rbp)
jmp 0x43ea3
movq -0x28(%rbp), %rdi
callq 0x43ef0
jmp 0x43eae
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x43eda
jmp 0x43ed1
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x39f70
jmp 0x43ee4
movq -0x30(%rbp), %rdi
callq 0x39f70
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xa520
nopl (%rax)
// File: errantlinguist[P]Forecast/src/forecast_io/MeasurementSystemDefaultNameArrayHolder.cpp
// Function: forecast_io::insertDefaultMeasurementSystemNames(std::array<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 4ul>&)
static void insertDefaultMeasurementSystemNames(MeasurementSystemNameArray& result)
{
	result[common::getEnumIndex(math::MeasurementSystem::CA)] = "Canadian Imperial";
	result[common::getEnumIndex(math::MeasurementSystem::SI)] = "SI";
	result[common::getEnumIndex(math::MeasurementSystem::UK)] = "UK Imperial";
	result[common::getEnumIndex(math::MeasurementSystem::US)] = "US Imperial";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x43fc0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x44050
movq %rax, %rdi
leaq 0x238bd(%rip), %rsi     # 0x677e0
callq 0xa300
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
callq 0x43fc0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x44050
movq %rax, %rdi
leaq 0x229bb(%rip), %rsi     # 0x6690b
callq 0xa300
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x2, %edi
callq 0x43fc0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x44050
movq %rax, %rdi
leaq 0x23875(%rip), %rsi     # 0x677f2
callq 0xa300
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x3, %edi
callq 0x43fc0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x44050
movq %rax, %rdi
leaq 0x23854(%rip), %rsi     # 0x677fe
callq 0xa300
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: errantlinguist[P]Forecast/src/forecast_io/parsers/AlertsFactoryParser.cpp
// Function: forecast_io::parsers::AlertsFactoryParser::handleArrayElement(json_object* const&)
void AlertsFactoryParser::handleArrayElement(json_object* const & arrayElement)
{
    json::JsonArrayParser<NotifyingAlertParser>::handleArrayElement(arrayElement);
    Alert alert = factory.create();
    for (listeners::AlertsListener* const & pListener : getListeners())
    {
        pListener->notifyAlert(alert);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x49100
movq -0xc0(%rbp), %rax
movq 0x50(%rax), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x80(%rbp), %rdi
callq *%rax
movq -0xc0(%rbp), %rdi
addq $0x10, %rdi
callq 0x49130
movq %rax, -0xb8(%rbp)
jmp 0x48ea8
movq -0xb8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x49150
movq %rax, -0xa0(%rbp)
movq -0x88(%rbp), %rdi
callq 0x49180
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x491b0
testb $0x1, %al
jne 0x48ef5
jmp 0x48f4e
leaq -0xa0(%rbp), %rdi
callq 0x491e0
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x80(%rbp), %rsi
callq *%rax
jmp 0x48f21
jmp 0x48f23
leaq -0xa0(%rbp), %rdi
callq 0x49210
jmp 0x48edc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3c920
jmp 0x48f60
leaq -0x80(%rbp), %rdi
callq 0x3c920
addq $0xc0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xa520
nopl (%rax)