LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nmmmnu[P]HM3/common/stringtokenizer.cc
// Function: StringTokenizer::getAll()
std::vector<StringRef> StringTokenizer::getAll(){
	rewind();

	std::vector<StringRef> v;

	while(hasNext())
		v.push_back(getNext());

	return v;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2050
movq 0x28(%rsp), %rdi
movb $0x0, 0x57(%rsp)
callq 0x2070
movq 0x20(%rsp), %rdi
callq 0x1ff0
movb %al, 0x17(%rsp)
jmp 0x1f59
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x1f63
jmp 0x1fb8
movq 0x20(%rsp), %rdi
callq 0x1df0
movq %rdx, (%rsp)
movq %rax, 0x8(%rsp)
jmp 0x1f78
movq 0x28(%rsp), %rdi
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x2080
jmp 0x1f9c
jmp 0x1f49
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x1a20
jmp 0x1fd8
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x1fce
movq 0x28(%rsp), %rdi
callq 0x1a20
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x10d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: ParseCommandLine(int, char**)
void ParseCommandLine(int argc, char* argv[])
{
	for(int i=1; i<argc; i++) {
		//Flag parameters:
		if( (strcmp( argv[i], "-h" ) == 0) || (strcmp( argv[i], "--help" ) == 0) ) {
			PrintHelp(argv[0]);
			exit(0);
		} else if( (strcmp( argv[i], "-l" ) == 0) || (strcmp( argv[i], "--list-file" ) == 0) ) {
			list_file = true;
		} else if( (strcmp( argv[i], "-v" ) == 0) || (strcmp( argv[i], "--verbose" ) == 0) ) {
			verbose_output = true;
		} else if( (i < argc - 1) && (ParseCommandLine_1Arg(i, argv)) ) {
			i++;
		} else if( (i < argc - 4) && (ParseCommandLine_4Args(i, argv)) ) {
			i += 4;
		} else {
			std::cout << "Invalid argument." << std::endl << std::endl;
			PrintHelp(argv[0]);
			exit(1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1087e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3a53(%rip), %rsi      # 0x14158
callq 0x22c0
cmpl $0x0, %eax
je 0x1072c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3a39(%rip), %rsi      # 0x1415b
callq 0x22c0
cmpl $0x0, %eax
jne 0x1073f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xf380
xorl %edi, %edi
callq 0x2230
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x38c0(%rip), %rsi      # 0x14012
callq 0x22c0
cmpl $0x0, %eax
je 0x10779
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x39f3(%rip), %rsi      # 0x14162
callq 0x22c0
cmpl $0x0, %eax
jne 0x10785
movb $0x1, 0xab20(%rip)      # 0x1b2a0
jmp 0x1086c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x39d6(%rip), %rsi      # 0x1416e
callq 0x22c0
cmpl $0x0, %eax
je 0x107bf
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x39bc(%rip), %rsi      # 0x14171
callq 0x22c0
cmpl $0x0, %eax
jne 0x107cb
movb $0x1, 0xaadb(%rip)      # 0x1b2a1
jmp 0x1086a
movl -0x14(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x107f5
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xfa80
testb $0x1, %al
jne 0x107ea
jmp 0x107f5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10868
movl -0x14(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x4, %ecx
cmpl %ecx, %eax
jge 0x1081f
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xfdb0
testb $0x1, %al
jne 0x10814
jmp 0x1081f
movl -0x14(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rbp)
jmp 0x10866
movq 0xa7b2(%rip), %rdi      # 0x1afd8
leaq 0x394e(%rip), %rsi      # 0x1417b
callq 0x21c0
movq %rax, %rdi
movq 0xa784(%rip), %rsi      # 0x1afc0
callq 0x21f0
movq %rax, %rdi
movq 0xa775(%rip), %rsi      # 0x1afc0
callq 0x21f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xf380
movl $0x1, %edi
callq 0x2230
jmp 0x10868
jmp 0x1086a
jmp 0x1086c
jmp 0x1086e
jmp 0x10870
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x106e6
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: CheckColor(int*)
void CheckColor(int* c) {
	if(c) {		//NULL pointer is okay
		for(int i=0; i<4; i++) {
			if((c[i] < 0) || (c[i] > 255)) {		//numbers must range between 0..255
				std::cout << "All color values must range between 0 and 255." << std::endl;
				exit(1);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1090a
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x10908
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x108cf
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0xff, (%rax,%rcx,4)
jle 0x108fb
movq 0xa702(%rip), %rdi      # 0x1afd8
leaq 0x38b0(%rip), %rsi      # 0x1418d
callq 0x21c0
movq %rax, %rdi
movq 0xa6d4(%rip), %rsi      # 0x1afc0
callq 0x21f0
movl $0x1, %edi
callq 0x2230
jmp 0x108fd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x108aa
jmp 0x1090a
addq $0x10, %rsp
popq %rbp
retq
// File: ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: CheckParameters()
void CheckParameters()
{
	CheckColor(light1_color);
	CheckColor(light2_color);
	CheckColor(light3_color);
	CheckColor(ambient_color);
	CheckColor(bg_color_ul);
	CheckColor(bg_color_ur);
	CheckColor(bg_color_ll);
	CheckColor(bg_color_lr);
	if((bg_opacity < 0) || (bg_opacity > 255)) {
		std::cout << "Background opacity must range between 0 and 255." << std::endl;
		exit(1);
	}
	if((title_linebreak <= 0) || (title_linebreak > 32)) {
		std::cout << "Invalid title linebreak." << std::endl;
		exit(1);
	}
	if(title_string) {
		if(strlen(title_string) > 32) {
			std::cout << "Title string exceeds character limit." << std::endl;
			exit(1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa9cd(%rip), %rdi      # 0x1b2e8
callq 0x10890
movq 0xa9c9(%rip), %rdi      # 0x1b2f0
callq 0x10890
movq 0xa9c5(%rip), %rdi      # 0x1b2f8
callq 0x10890
movq 0xa9c1(%rip), %rdi      # 0x1b300
callq 0x10890
movq 0xa9bd(%rip), %rdi      # 0x1b308
callq 0x10890
movq 0xa9b9(%rip), %rdi      # 0x1b310
callq 0x10890
movq 0xa9b5(%rip), %rdi      # 0x1b318
callq 0x10890
movq 0xa9b1(%rip), %rdi      # 0x1b320
callq 0x10890
cmpl $0x0, 0xa94d(%rip)      # 0x1b2c8
jl 0x10989
cmpl $0xff, 0xa941(%rip)     # 0x1b2c8
jle 0x109b5
movq 0xa648(%rip), %rdi      # 0x1afd8
leaq 0x3825(%rip), %rsi      # 0x141bc
callq 0x21c0
movq %rax, %rdi
movq 0xa61a(%rip), %rsi      # 0x1afc0
callq 0x21f0
movl $0x1, %edi
callq 0x2230
cmpl $0x0, 0xa86c(%rip)      # 0x1b228
jle 0x109c7
cmpl $0x20, 0xa863(%rip)     # 0x1b228
jle 0x109f3
movq 0xa60a(%rip), %rdi      # 0x1afd8
leaq 0x3818(%rip), %rsi      # 0x141ed
callq 0x21c0
movq %rax, %rdi
movq 0xa5dc(%rip), %rsi      # 0x1afc0
callq 0x21f0
movl $0x1, %edi
callq 0x2230
cmpq $0x0, 0xa8ad(%rip)      # 0x1b2a8
je 0x10a3d
movq 0xa8a4(%rip), %rdi      # 0x1b2a8
callq 0x20e0
cmpq $0x20, %rax
jbe 0x10a3b
movq 0xa5c2(%rip), %rdi      # 0x1afd8
leaq 0x37e9(%rip), %rsi      # 0x14206
callq 0x21c0
movq %rax, %rdi
movq 0xa594(%rip), %rsi      # 0x1afc0
callq 0x21f0
movl $0x1, %edi
callq 0x2230
jmp 0x10a3d
popq %rbp
retq
nop
// File: ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: WriteOutput(IconSys*)
void WriteOutput(IconSys* icon_sys) 
{
	if(verbose_output)
		std::cout << " * Writing output file to \"" << output_file << "\"...";
	try {
		icon_sys->WriteFile(output_file);
	} catch(Ghulbus::gbException e) {
		std::cout << "\nFile write error: \"" << output_file << "\"" << std::endl;
	}
	if(verbose_output)
		std::cout << "done." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
testb $0x1, 0x8ebe(%rip)      # 0x1b2a1
je 0x12416
movq 0x8bec(%rip), %rdi      # 0x1afd8
leaq 0x2049(%rip), %rsi      # 0x1443c
callq 0x21c0
movq %rax, %rdi
movq 0x8e96(%rip), %rsi      # 0x1b298
callq 0x21c0
movq %rax, %rdi
leaq 0x2047(%rip), %rsi      # 0x14458
callq 0x21c0
movq -0x8(%rbp), %rdi
movq 0x8e77(%rip), %rsi      # 0x1b298
callq 0x8fd0
jmp 0x12428
jmp 0x124d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x12521
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2250
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0xf120
movq -0x40(%rbp), %rdi
callq 0x20c0
movq 0x8b66(%rip), %rdi      # 0x1afd8
leaq 0x1fe4(%rip), %rsi      # 0x1445d
callq 0x21c0
movq %rax, -0x38(%rbp)
jmp 0x12484
movq -0x38(%rbp), %rdi
movq 0x8e09(%rip), %rsi      # 0x1b298
callq 0x21c0
movq %rax, -0x48(%rbp)
jmp 0x1249a
movq -0x48(%rbp), %rdi
leaq 0x1e57(%rip), %rsi      # 0x142fc
callq 0x21c0
movq %rax, -0x50(%rbp)
jmp 0x124b0
movq -0x50(%rbp), %rdi
movq 0x8b05(%rip), %rsi      # 0x1afc0
callq 0x21f0
jmp 0x124c2
leaq -0x30(%rbp), %rdi
callq 0xf170
callq 0x2350
testb $0x1, 0x8dca(%rip)      # 0x1b2a1
je 0x1251b
movq 0x8af8(%rip), %rdi      # 0x1afd8
leaq 0x1ddd(%rip), %rsi      # 0x142c4
callq 0x21c0
movq %rax, %rdi
movq 0x8aca(%rip), %rsi      # 0x1afc0
callq 0x21f0
jmp 0x1251b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf170
callq 0x2350
jmp 0x12519
jmp 0x12521
addq $0x50, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x2390
movq %rax, %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: void PrintColors<IconSys::IconSys_Color>(IconSys::IconSys_Color)
void PrintColors(T t)
{
	std::cout << std::hex << std::setfill('0')
		<< "0x" << std::setw(2) << t.GetR8() << ", 0x" << std::setw(2) << t.GetG8() 
		<< ", 0x" << std::setw(2) << t.GetB8() << ", 0x" << std::setw(2) << t.GetX8() 
		<< std::dec << std::setfill(' ') << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x83ee(%rip), %rdi      # 0x1afd8
leaq -0xc1(%rip), %rsi       # 0x12b30
callq 0x2090
movq %rax, -0x78(%rbp)
movl $0x30, %edi
callq 0x12b60
movq -0x78(%rbp), %rdi
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %esi
callq 0x2330
movq %rax, %rdi
leaq 0x18f2(%rip), %rsi      # 0x14510
callq 0x21c0
movq %rax, -0x70(%rbp)
movl $0x2, %edi
callq 0x12b80
movq -0x70(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
callq 0x2210
movq -0x38(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x9470
movq -0x68(%rbp), %rdi
movl %eax, %esi
callq 0x2370
movq %rax, %rdi
leaq 0x18ac(%rip), %rsi      # 0x1450e
callq 0x21c0
movq %rax, -0x60(%rbp)
movl $0x2, %edi
callq 0x12b80
movq -0x60(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x2210
movq -0x38(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x94b0
movq -0x58(%rbp), %rdi
movl %eax, %esi
callq 0x2370
movq %rax, %rdi
leaq 0x1868(%rip), %rsi      # 0x1450e
callq 0x21c0
movq %rax, -0x50(%rbp)
movl $0x2, %edi
callq 0x12b80
movq -0x50(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x2210
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x94f0
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x2370
movq %rax, %rdi
leaq 0x1824(%rip), %rsi      # 0x1450e
callq 0x21c0
movq %rax, -0x40(%rbp)
movl $0x2, %edi
callq 0x12b80
movq -0x40(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x2210
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x9530
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x2370
movq %rax, %rdi
leaq -0x18e(%rip), %rsi      # 0x12ba0
callq 0x2090
movq %rax, -0x28(%rbp)
movl $0x20, %edi
callq 0x12b60
movq -0x28(%rbp), %rdi
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %esi
callq 0x2330
movq %rax, %rdi
movq 0x8265(%rip), %rsi      # 0x1afc0
callq 0x21f0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: misohena[P]drawstars/drawstars.cpp
// Function: saturateKeepColor(ColorRGB<double>)
ColorType saturateKeepColor(ColorType c)
{
    const ColorElementType maxValue = std::max(std::max(c.r, c.g), c.b);
    if(maxValue > ColorElementType(1.0)){
        const ColorElementType invMaxValue = ColorElementType(1.0)/maxValue;
        return ColorType(
            c.r * invMaxValue,
            c.g * invMaxValue,
            c.b * invMaxValue);
    }
    else{
        return c;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rsi
addq $0x8, %rsi
callq 0xd7d0
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
callq 0xd7d0
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x1645c(%rip), %xmm1    # 0x1e058
ucomisd %xmm1, %xmm0
jbe 0x7c46
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movsd 0x16445(%rip), %xmm0    # 0x1e058
divsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%rax), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd 0x8(%rax), %xmm1
mulsd 0x18(%rsp), %xmm1
movsd 0x10(%rax), %xmm2
mulsd 0x18(%rsp), %xmm2
callq 0xd810
jmp 0x7c65
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: misohena[P]drawstars/drawstars.cpp
// Function: writeImageFile(char const*, Image<ColorRGB<double>> const&, int)
bool writeImageFile(const char *filename, const ImageType &image, int jpegQuality)
{
    const std::string ext = std::filesystem::path(filename).extension();
    if(ext == ".jpg" || ext == ".jpeg"){
        return writeJpegFile(filename, image, jpegQuality);
    }
    else if(ext == ".png"){
        return writePNGFile(filename, image);
    }
    else if(ext == ".bmp"){
        return writeBMPFile(filename, image);
    }
    else{
        return writeBMPFile(filename, image);
    }
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movl %edx, 0x9c(%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0xa8(%rsp), %rsi
movl $0x2, %edx
callq 0xd850
movq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xd950
jmp 0x7cbb
leaq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xda10
jmp 0x7ccc
leaq 0x50(%rsp), %rdi
callq 0xda40
leaq 0x28(%rsp), %rdi
callq 0xda40
leaq 0x164e9(%rip), %rsi     # 0x1e1d0
leaq 0x78(%rsp), %rdi
callq 0xda70
movb %al, 0xf(%rsp)
jmp 0x7cf7
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x7d25
jmp 0x7d01
leaq 0x164cd(%rip), %rsi     # 0x1e1d5
leaq 0x78(%rsp), %rdi
callq 0xda70
movb %al, 0xe(%rsp)
jmp 0x7d18
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x7d25
jmp 0x7db5
movq 0xa8(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movl 0x9c(%rsp), %edx
callq 0xdaa0
movb %al, 0xd(%rsp)
jmp 0x7d47
movb 0xd(%rsp), %al
andb $0x1, %al
movb %al, 0xb7(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x7e8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x7d89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xda40
leaq 0x28(%rsp), %rdi
callq 0xda40
jmp 0x7ea9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x4240
jmp 0x7ea9
leaq 0x164b5(%rip), %rsi     # 0x1e271
leaq 0x78(%rsp), %rdi
callq 0xda70
movb %al, 0xc(%rsp)
jmp 0x7dcc
movb 0xc(%rsp), %al
testb $0x1, %al
jne 0x7dd6
jmp 0x7e0b
movq 0xa8(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xde90
movb %al, 0xb(%rsp)
jmp 0x7df1
movb 0xb(%rsp), %al
andb $0x1, %al
movb %al, 0xb7(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x7e8e
leaq 0x163c9(%rip), %rsi     # 0x1e1db
leaq 0x78(%rsp), %rdi
callq 0xda70
movb %al, 0xa(%rsp)
jmp 0x7e22
movb 0xa(%rsp), %al
testb $0x1, %al
jne 0x7e2c
jmp 0x7e5e
movq 0xa8(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xe3f0
movb %al, 0x9(%rsp)
jmp 0x7e47
movb 0x9(%rsp), %al
andb $0x1, %al
movb %al, 0xb7(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x7e8e
movq 0xa8(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xe3f0
movb %al, 0x8(%rsp)
jmp 0x7e79
movb 0x8(%rsp), %al
andb $0x1, %al
movb %al, 0xb7(%rsp)
movl $0x1, 0x18(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x4240
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: misohena[P]drawstars/drawstars.cpp
// Function: temperatureToRGB(double)
ColorType temperatureToRGB(double k)
{
    k = clamp(k, 1000.0, 40000.0) / 100.0;
    return ColorType(
        k <= 66.0 ? 1.0 : clamp(1.29293618606274509804 * std::pow(k - 60.0, -0.1332047592), 0.0, 1.0),
        k <= 66.0 ? clamp(0.39008157876901960784 * std::log(k) - 0.63184144378862745098, 0.0, 1.0) : clamp(1.12989086089529411765 * std::pow(k - 60.0, -0.0755148492), 0.0, 1.0),
        k >= 66.0 ? 1.0 : k <= 19.0 ? 0.0 : clamp(0.54320678911019607843 * std::log(k - 10.0) - 1.19625408914, 0.0, 1.0) );
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, 0x38(%rsp)
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x16196(%rip), %xmm1    # 0x1e078
movsd 0x16196(%rip), %xmm2    # 0x1e080
callq 0xe9a0
movsd 0x16179(%rip), %xmm1    # 0x1e070
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x1615f(%rip), %xmm0    # 0x1e068
ucomisd 0x40(%rsp), %xmm0
jb 0x7f21
movsd 0x1613f(%rip), %xmm0    # 0x1e058
movsd %xmm0, 0x28(%rsp)
jmp 0x7f65
movsd 0x40(%rsp), %xmm0
movsd 0x16169(%rip), %xmm1    # 0x1e098
subsd %xmm1, %xmm0
movsd 0x16155(%rip), %xmm1    # 0x1e090
callq 0x45d0
movaps %xmm0, %xmm1
movsd 0x1613d(%rip), %xmm0    # 0x1e088
mulsd %xmm1, %xmm0
xorps %xmm1, %xmm1
movsd 0x160fe(%rip), %xmm2    # 0x1e058
callq 0xe9a0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x160ef(%rip), %xmm0    # 0x1e068
ucomisd 0x40(%rsp), %xmm0
jb 0x7fbc
movsd 0x40(%rsp), %xmm0
callq 0x42f0
movsd 0x1611c(%rip), %xmm1    # 0x1e0b0
mulsd %xmm1, %xmm0
movsd 0x16118(%rip), %xmm1    # 0x1e0b8
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
movsd 0x160a9(%rip), %xmm2    # 0x1e058
callq 0xe9a0
movsd %xmm0, 0x18(%rsp)
jmp 0x8000
movsd 0x40(%rsp), %xmm0
movsd 0x160ce(%rip), %xmm1    # 0x1e098
subsd %xmm1, %xmm0
movsd 0x160d2(%rip), %xmm1    # 0x1e0a8
callq 0x45d0
movaps %xmm0, %xmm1
movsd 0x160ba(%rip), %xmm0    # 0x1e0a0
mulsd %xmm1, %xmm0
xorps %xmm1, %xmm1
movsd 0x16063(%rip), %xmm2    # 0x1e058
callq 0xe9a0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x1604e(%rip), %xmm1    # 0x1e068
ucomisd %xmm1, %xmm0
jb 0x8030
movsd 0x16030(%rip), %xmm0    # 0x1e058
movsd %xmm0, 0x8(%rsp)
jmp 0x8099
movsd 0x16088(%rip), %xmm0    # 0x1e0c0
ucomisd 0x40(%rsp), %xmm0
jb 0x804a
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
jmp 0x808e
movsd 0x40(%rsp), %xmm0
movsd 0x16080(%rip), %xmm1    # 0x1e0d8
subsd %xmm1, %xmm0
callq 0x42f0
movsd 0x1605f(%rip), %xmm1    # 0x1e0c8
mulsd %xmm1, %xmm0
movsd 0x1605b(%rip), %xmm1    # 0x1e0d0
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
movsd 0x15fd4(%rip), %xmm2    # 0x1e058
callq 0xe9a0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
movq 0x30(%rsp), %rdi
movsd 0x8(%rsp), %xmm2
callq 0xd810
movq 0x38(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: misohena[P]drawstars/drawstars.cpp
// Function: dirRADec(float, float)
Vec4F dirRADec(float ra, float dec)
{
    // x+:6h, y+: North, z+:0h(Vernal Equinox)
    return Vec4F(
        std::cos(dec) * std::sin(ra),
        std::sin(dec),
        std::cos(dec) * std::cos(ra),
        1);
}

// Assembly:
subq $0x28, %rsp
movss %xmm0, 0x14(%rsp)
movss %xmm1, 0x10(%rsp)
movss 0x10(%rsp), %xmm0
callq 0xea10
movss %xmm0, (%rsp)
movss 0x14(%rsp), %xmm0
callq 0xea30
movaps %xmm0, %xmm1
movss (%rsp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x10(%rsp), %xmm0
callq 0xea30
movss %xmm0, 0x8(%rsp)
movss 0x10(%rsp), %xmm0
callq 0xea10
movss %xmm0, 0x4(%rsp)
movss 0x14(%rsp), %xmm0
callq 0xea10
movss 0x4(%rsp), %xmm2
movss 0x8(%rsp), %xmm1
movaps %xmm0, %xmm3
movss 0xc(%rsp), %xmm0
mulss %xmm3, %xmm2
leaq 0x18(%rsp), %rdi
movss 0x15ebc(%rip), %xmm3    # 0x1e00c
callq 0xea50
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: misohena[P]drawstars/drawstars.cpp
// Function: convertRADecToAzEl(float, float, Mat4<float> const&)
std::pair<float, float> convertRADecToAzEl(float ra, float dec, const Mat4F &matEquToHor)
{
    const Vec4F dirEquatorial = dirRADec(ra, dec);
    const Vec4F dirHorizontal = matEquToHor * dirEquatorial;
    const float x = dirHorizontal.x;//for East
    const float y = dirHorizontal.y;//for Zenith
    const float z = dirHorizontal.z;//for South
    const float az = std::atan2(-x, z);
    const float el = std::asin(y);

    return {az*RAD2DEG, el*RAD2DEG};
}

// Assembly:
subq $0x68, %rsp
movss %xmm0, 0x5c(%rsp)
movss %xmm1, 0x58(%rsp)
movq %rdi, 0x50(%rsp)
movss 0x5c(%rsp), %xmm0
movss 0x58(%rsp), %xmm1
callq 0x80c0
movlpd %xmm0, 0x40(%rsp)
movlpd %xmm1, 0x48(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xeaa0
movlpd %xmm0, 0x30(%rsp)
movlpd %xmm1, 0x38(%rsp)
movss 0x30(%rsp), %xmm0
movss %xmm0, 0x2c(%rsp)
movss 0x34(%rsp), %xmm0
movss %xmm0, 0x28(%rsp)
movss 0x38(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movaps 0x15f08(%rip), %xmm1    # 0x1e1a0
movss 0x2c(%rsp), %xmm0
pxor %xmm1, %xmm0
movss 0x24(%rsp), %xmm1
callq 0xebb0
movss %xmm0, 0x20(%rsp)
movss 0x28(%rsp), %xmm0
callq 0xebd0
movss %xmm0, 0x1c(%rsp)
movss 0x20(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x15e0a(%rip), %xmm1    # 0x1e0e0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movss 0x1c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xebf0
movsd 0x60(%rsp), %xmm0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: misohena[P]drawstars/drawstars.cpp
// Function: convertUnixSecondsToGreenwichMeanSiderealTime(double)
double convertUnixSecondsToGreenwichMeanSiderealTime(double unixSeconds)
{
    ///@todo validation
    ///@todo add leap seconds
    const double jd00 = unixSeconds / SEC24H + (2440587.5 - 2451545.0); //2440587.5=Unix Epoch(in JD), 2451545.0=J2000.0(in JD)
    const double t = jd00 / 36525.0; //36525.0=Days per Julian century
    const double f = SEC24H * std::fmod(jd00, 1.0);
    const double A = 24110.54841  -  SEC24H / 2.0;
    const double B = 8640184.812866;
    const double C = 0.093104;
    const double D =  -6.2e-6;
    const double gmst = ((A + (B + (C + D * t) * t) * t) + f) * SEC2RAD; //[rad]
    const double gmstNormalized = std::fmod(gmst, 2*PI);
    return gmstNormalized < 0 ? (2*PI) + gmstNormalized : gmstNormalized;
}

// Assembly:
subq $0x58, %rsp
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x15de0(%rip), %xmm1    # 0x1e118
divsd %xmm1, %xmm0
movsd 0x15de4(%rip), %xmm1    # 0x1e128
addsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x48(%rsp), %xmm0
movsd 0x15dc4(%rip), %xmm1    # 0x1e120
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x48(%rsp), %xmm0
movsd 0x15ce4(%rip), %xmm1    # 0x1e058
callq 0x4460
movaps %xmm0, %xmm1
movsd 0x15d94(%rip), %xmm0    # 0x1e118
mulsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x15d62(%rip), %xmm0    # 0x1e0f8
movsd %xmm0, 0x30(%rsp)
movsd 0x15d5c(%rip), %xmm0    # 0x1e100
movsd %xmm0, 0x28(%rsp)
movsd 0x15d5e(%rip), %xmm0    # 0x1e110
movsd %xmm0, 0x20(%rsp)
movsd 0x15d48(%rip), %xmm0    # 0x1e108
movsd %xmm0, 0x18(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x15d34(%rip), %xmm1    # 0x1e108
mulsd %xmm1, %xmm0
movsd 0x15d30(%rip), %xmm1    # 0x1e110
addsd %xmm1, %xmm0
movsd 0x40(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x15d0a(%rip), %xmm1    # 0x1e100
addsd %xmm1, %xmm0
movsd 0x40(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x15cec(%rip), %xmm1    # 0x1e0f8
addsd %xmm1, %xmm0
addsd 0x38(%rsp), %xmm0
movsd 0x15cd2(%rip), %xmm1    # 0x1e0f0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x15cb2(%rip), %xmm1    # 0x1e0e8
callq 0x4460
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x8(%rsp), %xmm0
jbe 0x8461
movsd 0x15c94(%rip), %xmm0    # 0x1e0e8
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0x846c
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: misohena[P]drawstars/drawstars.cpp
// Function: createProjectionMatrix(double, double, double, double)
Mat4F createProjectionMatrix(double screenW, double screenH, double fovY, double viewZ)
{
    Mat4F mat = Mat4F::perspective(fovY, screenW, screenH, 0.0125, 3.0);
    if(viewZ != 0){
        mat = mat * Mat4F::translate(0, 0, -viewZ);
    }
    return mat;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movsd %xmm0, 0xb0(%rsp)
movsd %xmm1, 0xa8(%rsp)
movsd %xmm2, 0xa0(%rsp)
movsd %xmm3, 0x98(%rsp)
movsd 0xa0(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movsd 0xb0(%rsp), %xmm1
cvtsd2ss %xmm1, %xmm1
movsd 0xa8(%rsp), %xmm2
cvtsd2ss %xmm2, %xmm2
movss 0x15939(%rip), %xmm3    # 0x1e010
movss 0x15935(%rip), %xmm4    # 0x1e014
callq 0xf620
movsd 0x98(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x86fa
jp 0x86fa
jmp 0x8756
movsd 0x98(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
cvtsd2ss %xmm0, %xmm2
leaq 0x18(%rsp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xf790
movq 0x8(%rsp), %rsi
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xec30
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
movl $0x40, %edx
callq 0x4300
movq 0x10(%rsp), %rax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: misohena[P]drawstars/drawstars.cpp
// Function: float fromStrView<float>(std::basic_string_view<char, std::char_traits<char>>)
float fromStrView<float>(std::string_view str)
{
    if(str.size() > 1 && str[0] == 'M'){ //M6 means Magnitude 6
        return mag2flux(std::stof(std::string(str.begin() + 1, str.end())));
    }
    else{
        return std::stof(std::string(str));
    }
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0xa8(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0xf910
cmpq $0x1, %rax
jbe 0x8972
leaq 0xa0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf920
movsbl (%rax), %eax
cmpl $0x4d, %eax
jne 0x8972
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xf990
movq 0x20(%rsp), %rdi
incq %rax
movq %rax, 0x28(%rsp)
callq 0xf9a0
movq %rax, 0x30(%rsp)
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x4600
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
leaq 0x80(%rsp), %rdi
callq 0xf9c0
jmp 0x88e1
xorl %eax, %eax
movl %eax, %esi
leaq 0x80(%rsp), %rdi
callq 0xf950
movss %xmm0, 0x1c(%rsp)
jmp 0x88fa
movss 0x1c(%rsp), %xmm0
callq 0x7b80
movss %xmm0, 0x18(%rsp)
jmp 0x890d
movss 0x18(%rsp), %xmm0
movss %xmm0, 0xb4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x4240
leaq 0x7f(%rsp), %rdi
callq 0x43e0
jmp 0x8a09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x8963
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x4240
leaq 0x7f(%rsp), %rdi
callq 0x43e0
jmp 0x8a1a
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4600
movq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0xf890
jmp 0x899a
xorl %eax, %eax
movl %eax, %esi
leaq 0x48(%rsp), %rdi
callq 0xf950
movss %xmm0, 0xc(%rsp)
jmp 0x89b0
movss 0xc(%rsp), %xmm0
movss %xmm0, 0xb4(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4240
leaq 0x47(%rsp), %rdi
callq 0x43e0
jmp 0x8a09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x89fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4240
leaq 0x47(%rsp), %rdi
callq 0x43e0
jmp 0x8a1a
movss 0xb4(%rsp), %xmm0
addq $0xb8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: misohena[P]drawstars/drawstars.cpp
// Function: bool fromStrView<bool>(std::basic_string_view<char, std::char_traits<char>>)
bool fromStrView<bool>(std::string_view str)
{
    if(str == "true"){
        return true;
    }
    else if(str == "false"){
        return false;
    }
    else{
        return std::stoi(std::string(str)) != 0;
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x1576d(%rip), %rsi     # 0x1e1e0
callq 0xfad0
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x78(%rsp), %rcx
callq 0xfa40
testb $0x1, %al
jne 0x8a9d
jmp 0x8aaa
movb $0x1, 0xa7(%rsp)
jmp 0x8b9f
movq 0x90(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x15715(%rip), %rsi     # 0x1e1e5
callq 0xfad0
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x58(%rsp), %rcx
callq 0xfa40
testb $0x1, %al
jne 0x8af4
jmp 0x8b01
movb $0x0, 0xa7(%rsp)
jmp 0x8b9f
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4600
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xf890
jmp 0x8b29
xorl %eax, %eax
movl %eax, %esi
leaq 0x30(%rsp), %rdi
movl $0xa, %edx
callq 0xf840
movl %eax, 0xc(%rsp)
jmp 0x8b42
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4240
leaq 0x2f(%rsp), %rdi
callq 0x43e0
jmp 0x8b9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x8b93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4240
leaq 0x2f(%rsp), %rdi
callq 0x43e0
jmp 0x8bb0
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x45f0
nopw (%rax,%rax)
// File: misohena[P]drawstars/drawstars.cpp
// Function: findOption(std::basic_string_view<char, std::char_traits<char>>)
const Option *findOption(std::string_view name)
{
    for(const auto &cat : optionCategories){
        for(const auto &opt : cat.options){
            const auto it = std::find(opt.names.begin(), opt.names.end(), name);
            if(it != opt.names.end()){
                return &opt;
            }
        }
    }
    return nullptr;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x216bb(%rip), %rax     # 0x2a380
movq %rax, 0x58(%rsp)
leaq 0x216af(%rip), %rdi     # 0x2a380
callq 0x10430
movq %rax, 0x50(%rsp)
leaq 0x2169e(%rip), %rdi     # 0x2a380
callq 0x10460
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x10490
testb $0x1, %al
jne 0x8d04
jmp 0x8dec
leaq 0x50(%rsp), %rdi
callq 0x104d0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x104e0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x10510
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x10540
testb $0x1, %al
jne 0x8d57
jmp 0x8ddb
leaq 0x30(%rsp), %rdi
callq 0x10580
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10670
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x105e0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10670
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x106a0
testb $0x1, %al
jne 0x8dbe
jmp 0x8dca
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x8df5
jmp 0x8dcc
leaq 0x30(%rsp), %rdi
callq 0x105a0
jmp 0x8d3f
jmp 0x8ddd
leaq 0x50(%rsp), %rdi
callq 0x105c0
jmp 0x8cec
movq $0x0, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nop
// File: misohena[P]drawstars/drawstars.cpp
// Function: emitOption(Options&, Option const*, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>)
bool emitOption(Options &options, const Option *opt, std::string_view name, std::string_view value)
{
    try{
        opt->type->setArgument(options, value);
        if(opt->specified){
            options.*(opt->specified) = true;
        }
        return true;
    }
    catch(const std::logic_error &e){ //sto? throws invalid_argument or out_of_range
        error("Invalid option value %s (%s)",
            std::string(value).c_str(),
            std::string(name).c_str());
        return false;
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xa0(%rsp)
movq %r9, 0xa8(%rsp)
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
addq $0x18, %rdi
callq 0x10590
movq %rax, %rdi
movq 0x98(%rsp), %rsi
movups 0xa0(%rsp), %xmm0
movaps %xmm0, 0x80(%rsp)
movq 0x80(%rsp), %rdx
movq 0x88(%rsp), %rcx
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x8e7e
movq 0x90(%rsp), %rax
cmpq $-0x1, 0x28(%rax)
je 0x8f90
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rcx
movq 0x28(%rcx), %rcx
movb $0x1, (%rax,%rcx)
jmp 0x8f90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x900a
movq 0x78(%rsp), %rdi
callq 0x4140
movq %rax, 0x68(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4600
movq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0xf890
jmp 0x8f04
leaq 0x48(%rsp), %rdi
callq 0x4150
movq %rax, (%rsp)
leaq 0x1f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4600
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xf890
jmp 0x8f3a
leaq 0x20(%rsp), %rdi
callq 0x4150
movq (%rsp), %rsi
movq %rax, %rdx
leaq 0x1549c(%rip), %rdi     # 0x1e3ee
callq 0x106e0
jmp 0x8f59
leaq 0x20(%rsp), %rdi
callq 0x4240
leaq 0x1f(%rsp), %rdi
callq 0x43e0
leaq 0x48(%rsp), %rdi
callq 0x4240
leaq 0x47(%rsp), %rdi
callq 0x43e0
movb $0x0, 0xc7(%rsp)
callq 0x4570
jmp 0x8ff9
movb $0x1, 0xc7(%rsp)
jmp 0x8ff9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x8fe6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x8fd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4240
leaq 0x1f(%rsp), %rdi
callq 0x43e0
leaq 0x48(%rsp), %rdi
callq 0x4240
leaq 0x47(%rsp), %rdi
callq 0x43e0
callq 0x4570
jmp 0x8ff7
jmp 0x900a
movb 0xc7(%rsp), %al
andb $0x1, %al
addq $0xc8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x45f0
movq %rax, %rdi
callq 0x10740
nopl (%rax)
// File: misohena[P]drawstars/./image.h
// Function: Image<ColorRGB<double>> apply<ColorRGB<double>, main::$_4>(Image<ColorRGB<double>> const&, main::$_4)
Image<T> apply(const Image<T> &srcImage, F f)
{
    Image<T> rv(srcImage.width(), srcImage.height());
    auto srcEnd = srcImage.end();
    auto src = srcImage.begin();
    auto dst = rv.begin();
    for(; src != srcEnd; ++src, ++dst){
        *dst = f(*src);
    }
    return std::move(rv);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
leaq 0xd0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x11c00
movl %eax, 0x44(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x11c10
movl 0x44(%rsp), %esi
movl %eax, %edx
leaq 0xa8(%rsp), %rdi
callq 0x108f0
movq 0xb8(%rsp), %rdi
callq 0x1d9a0
movq %rax, 0x48(%rsp)
jmp 0xc436
movq 0x48(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x1d9e0
movq %rax, 0x20(%rsp)
jmp 0xc457
movq 0x20(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x1a8a0
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rax
cmpq 0xa0(%rsp), %rax
je 0xc53f
movq 0x38(%rsp), %rsi
movq 0x88(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x60(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rax)
leaq 0x68(%rsp), %rdi
callq 0xd6d0
jmp 0xc4cd
movq 0x80(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, (%rax)
movq 0x70(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x78(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x88(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x88(%rsp)
movq 0x80(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x80(%rsp)
jmp 0xc479
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x10c10
jmp 0xc56d
movq 0x28(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x1a8e0
jmp 0xc553
leaq 0xa8(%rsp), %rdi
callq 0x10c10
movq 0x30(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x98(%rsp), %rdi
callq 0x45f0
nopw (%rax,%rax)
// File: misohena[P]drawstars/./vmath.h
// Function: Vec4<float> operator*<float>(Mat4<float> const&, Vec4<float> const&)
Vec4<T> operator*(const Mat4<T> &lhs, const Vec4<T> &rhs)
{
    return Vec4<T>(
        lhs.e00*rhs.x + lhs.e01*rhs.y + lhs.e02*rhs.z + lhs.e03*rhs.w,
        lhs.e10*rhs.x + lhs.e11*rhs.y + lhs.e12*rhs.z + lhs.e13*rhs.w,
        lhs.e20*rhs.x + lhs.e21*rhs.y + lhs.e22*rhs.z + lhs.e23*rhs.w,
        lhs.e30*rhs.x + lhs.e31*rhs.y + lhs.e32*rhs.z + lhs.e33*rhs.w);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movss 0x10(%rax), %xmm2
movss (%rcx), %xmm7
movss 0x4(%rcx), %xmm8
mulss %xmm8, %xmm2
movss (%rax), %xmm0
movss 0x4(%rax), %xmm1
mulss %xmm7, %xmm0
addss %xmm2, %xmm0
movss 0x20(%rax), %xmm2
movss 0x8(%rcx), %xmm6
mulss %xmm6, %xmm2
addss %xmm0, %xmm2
movss 0x30(%rax), %xmm0
movss 0xc(%rcx), %xmm5
mulss %xmm5, %xmm0
addss %xmm2, %xmm0
movss 0x14(%rax), %xmm2
mulss %xmm8, %xmm2
mulss %xmm7, %xmm1
addss %xmm2, %xmm1
movss 0x24(%rax), %xmm2
mulss %xmm6, %xmm2
addss %xmm1, %xmm2
movss 0x34(%rax), %xmm1
mulss %xmm5, %xmm1
addss %xmm2, %xmm1
movss 0x8(%rax), %xmm2
movss 0x18(%rax), %xmm3
mulss %xmm8, %xmm3
mulss %xmm7, %xmm2
addss %xmm3, %xmm2
movss 0x28(%rax), %xmm3
mulss %xmm6, %xmm3
addss %xmm2, %xmm3
movss 0x38(%rax), %xmm2
mulss %xmm5, %xmm2
addss %xmm3, %xmm2
movss 0xc(%rax), %xmm3
movss 0x1c(%rax), %xmm4
mulss %xmm8, %xmm4
mulss %xmm7, %xmm3
addss %xmm4, %xmm3
movss 0x2c(%rax), %xmm4
mulss %xmm6, %xmm4
addss %xmm3, %xmm4
movss 0x3c(%rax), %xmm3
mulss %xmm5, %xmm3
addss %xmm4, %xmm3
leaq 0x18(%rsp), %rdi
callq 0xea50
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: misohena[P]drawstars/./vmath.h
// Function: Mat4<float>::perspective(float, float, float, float, float)
static Mat4 perspective(Element fovYDeg, Element screenW, Element screenH, Element nearZ, Element farZ)
    {
        const Element fovYRad = fovYDeg * DEG2RAD;
        const Element aspectRatio = screenH / screenW;

        const Element h = 1.0 / std::tan(fovYRad / 2.0);
        const Element w = h * aspectRatio;
        const Element zNearFar = nearZ - farZ;
        return Mat4(
            w, 0, 0, 0,
            0, h, 0, 0,
            0, 0, (farZ+nearZ)/zNearFar, -1,
            0, 0, 2*nearZ*farZ/zNearFar, 0);
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x40(%rsp)
movq %rdi, 0x48(%rsp)
movss %xmm0, 0x74(%rsp)
movss %xmm1, 0x70(%rsp)
movss %xmm2, 0x6c(%rsp)
movss %xmm3, 0x68(%rsp)
movss %xmm4, 0x64(%rsp)
movss 0x74(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xead2(%rip), %xmm1     # 0x1e130
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x6c(%rsp), %xmm0
divss 0x70(%rsp), %xmm0
movss %xmm0, 0x5c(%rsp)
movss 0x60(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xeab8(%rip), %xmm1     # 0x1e148
divsd %xmm1, %xmm0
callq 0x4200
movq 0x40(%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0xe9af(%rip), %xmm0     # 0x1e058
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x58(%rsp)
movss 0x58(%rsp), %xmm0
mulss 0x5c(%rsp), %xmm0
movss %xmm0, 0x54(%rsp)
movss 0x68(%rsp), %xmm0
subss 0x64(%rsp), %xmm0
movss %xmm0, 0x50(%rsp)
movss 0x54(%rsp), %xmm0
movss 0x58(%rsp), %xmm5
movss 0x64(%rsp), %xmm11
addss 0x68(%rsp), %xmm11
divss 0x50(%rsp), %xmm11
movss 0xe917(%rip), %xmm9     # 0x1e01c
mulss 0x68(%rsp), %xmm9
mulss 0x64(%rsp), %xmm9
divss 0x50(%rsp), %xmm9
xorps %xmm8, %xmm8
movss 0xe8f1(%rip), %xmm10    # 0x1e018
movaps %xmm8, %xmm1
movaps %xmm8, %xmm2
movaps %xmm8, %xmm3
movaps %xmm8, %xmm4
movaps %xmm8, %xmm6
movaps %xmm8, %xmm7
movss %xmm8, (%rsp)
movss %xmm8, 0x8(%rsp)
movss %xmm11, 0x10(%rsp)
movss %xmm10, 0x18(%rsp)
movss %xmm8, 0x20(%rsp)
movss %xmm8, 0x28(%rsp)
movss %xmm9, 0x30(%rsp)
movss %xmm8, 0x38(%rsp)
callq 0x12050
movq 0x48(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: misohena[P]drawstars/./image.h
// Function: Image<ColorRGB<double>> readRawFile<Image<ColorRGB<double>>>(char const*)
ImageT readRawFile(const char *filename)
{
    ImageT image;
    if(File file = File(filename, "rb")){
        unsigned int w = 0, h = 0;
        std::fread(&w, sizeof(w), 1, file);
        std::fread(&h, sizeof(h), 1, file);
        if(w > 0 && h > 0 && w <= 65536 && h <= 65536){
            image.reset(w, h);
            if(std::fread(image.begin(), image.sizeInBytes(), 1, file) != 1){
                image.reset(0, 0);
            }
        }
    }
    return std::move(image);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1a770
movq 0x58(%rsp), %rsi
leaq 0xdb2b(%rip), %rdx      # 0x1e54c
leaq 0x40(%rsp), %rdi
callq 0x11bb0
jmp 0x10a2d
leaq 0x40(%rsp), %rdi
callq 0x11bf0
cmpq $0x0, %rax
je 0x10b70
movl $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x11bf0
movq %rax, %rcx
leaq 0x30(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x4510
jmp 0x10a74
leaq 0x40(%rsp), %rdi
callq 0x11bf0
movq %rax, %rcx
leaq 0x2c(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x4510
jmp 0x10a97
cmpl $0x0, 0x30(%rsp)
jbe 0x10b6e
cmpl $0x0, 0x2c(%rsp)
jbe 0x10b6e
cmpl $0x10000, 0x30(%rsp)    # imm = 0x10000
ja 0x10b6e
cmpl $0x10000, 0x2c(%rsp)    # imm = 0x10000
ja 0x10b6e
movl 0x30(%rsp), %esi
movl 0x2c(%rsp), %edx
leaq 0x48(%rsp), %rdi
callq 0x1a7a0
jmp 0x10add
leaq 0x48(%rsp), %rdi
callq 0x1a8a0
movq %rax, 0x10(%rsp)
jmp 0x10aee
leaq 0x48(%rsp), %rdi
callq 0x1a8c0
movq %rax, 0x8(%rsp)
jmp 0x10aff
leaq 0x40(%rsp), %rdi
callq 0x11bf0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rcx
movl $0x1, %edx
callq 0x4510
movq %rax, (%rsp)
jmp 0x10b26
movq (%rsp), %rax
cmpq $0x1, %rax
je 0x10b6c
leaq 0x48(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x1a7a0
jmp 0x10b40
jmp 0x10b6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x10b9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x11d20
jmp 0x10b9f
jmp 0x10b6e
jmp 0x10b70
leaq 0x40(%rsp), %rdi
callq 0x11d20
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1a8e0
jmp 0x10b8b
leaq 0x48(%rsp), %rdi
callq 0x10c10
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
leaq 0x48(%rsp), %rdi
callq 0x10c10
movq 0x38(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: misohena[P]drawstars/./image.h
// Function: Image<ColorRGB<double>>::operator=(Image<ColorRGB<double>>&&)
Image &operator=(Image &&rhs)
    {
        width_ = rhs.width_;
        height_ = rhs.height_;
        pixels_ = std::move(rhs.pixels_);
        return *this;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x1aa40
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: misohena[P]drawstars/./image.h
// Function: bool writeRawFile<Image<ColorRGB<double>>>(char const*, Image<ColorRGB<double>>&)
bool writeRawFile(const char *filename, ImageT &image)
{
    if(File file = File(filename, "wb")){
        const unsigned int w = image.width();
        const unsigned int h = image.height();
        std::fwrite(&w, sizeof(w), 1, file);
        std::fwrite(&h, sizeof(h), 1, file);
        std::fwrite(image.begin(), image.sizeInBytes(), 1, file);
        return true;
    }
    else{
        return false;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x28(%rsp), %rdi
leaq 0xd83f(%rip), %rdx      # 0x1e4ae
callq 0x11bb0
leaq 0x28(%rsp), %rdi
callq 0x11bf0
cmpq $0x0, %rax
je 0x10d54
movq 0x30(%rsp), %rdi
callq 0x11c00
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11c10
movl %eax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x11bf0
movq %rax, %rcx
leaq 0x24(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x4670
jmp 0x10cc7
leaq 0x28(%rsp), %rdi
callq 0x11bf0
movq %rax, %rcx
leaq 0x20(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x4670
jmp 0x10cea
movq 0x30(%rsp), %rdi
callq 0x1a8a0
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x1a8c0
movq %rax, 0x8(%rsp)
jmp 0x10d09
leaq 0x28(%rsp), %rdi
callq 0x11bf0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rcx
movl $0x1, %edx
callq 0x4670
jmp 0x10d2b
movb $0x1, 0x47(%rsp)
movl $0x1, 0x10(%rsp)
jmp 0x10d61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x11d20
jmp 0x10d76
movb $0x0, 0x47(%rsp)
movl $0x1, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x11d20
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x45f0
// File: misohena[P]drawstars/drawstars.cpp
// Function: OptionEnum<ProjectionMode>::setArgument(Options&, std::basic_string_view<char, std::char_traits<char>>) const
void setArgument(Options &options, std::string_view str) const override
    {
        for(const auto &nameVal : candidates){
            if(nameVal.first == str){
                options.*dst = nameVal.second;
                return;
            }
        }
        throw std::invalid_argument("Unknown value name");
    }

// Assembly:
subq $0x88, %rsp
movq %rdx, 0x78(%rsp)
movq %rcx, 0x80(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x18, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x170e0
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x17110
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x17140
testb $0x1, %al
jne 0x16ef7
jmp 0x16f84
leaq 0x58(%rsp), %rdi
callq 0x17180
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x17190
testb $0x1, %al
jne 0x16f52
jmp 0x16f73
movq 0x10(%rsp), %rcx
movq 0x48(%rsp), %rax
movl 0x10(%rax), %edx
movq 0x68(%rsp), %rax
movq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx)
addq $0x88, %rsp
retq
jmp 0x16f75
leaq 0x58(%rsp), %rdi
callq 0x17220
jmp 0x16edf
movl $0x10, %edi
callq 0x41c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x7573(%rip), %rsi      # 0x1e513
callq 0x4650
jmp 0x16fa7
movq 0x8(%rsp), %rdi
movq 0x13035(%rip), %rsi     # 0x29fe8
movq 0x1301e(%rip), %rdx     # 0x29fd8
callq 0x45b0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x4290
movq 0x20(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)