LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::basic_node(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>> const&)
basic_node(const basic_node& o, const allocator_type& al)
                noexcept(value::is_nothrow_copy_constructible<basic_node>::value)
            :   kind_(o.kind_), alloc_(al)
            {
                switch (o.kind_) {
#                   define CXON_JSON_TYPE_DEF(T)    case node_kind::T: value::copy_construct<T>(*this, o); break
                        CXON_JSON_TYPE_DEF(object);
                        CXON_JSON_TYPE_DEF(array);
                        CXON_JSON_TYPE_DEF(string);
                        CXON_JSON_TYPE_DEF(real);
                        CXON_JSON_TYPE_DEF(sint);
                        CXON_JSON_TYPE_DEF(uint);
                        CXON_JSON_TYPE_DEF(boolean);
                        CXON_JSON_TYPE_DEF(null);
#                   undef CXON_JSON_TYPE_DEF
                }
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
movl 0x20(%rsi), %eax
cmpq $0x7, %rax
ja 0x6ba6e
movq %rdi, %rbx
leaq 0x6d019(%rip), %rcx     # 0xd89f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
movq %rax, (%rbx)
jmp 0x6ba6e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x725fe
movq $0x0, (%rbx)
jmp 0x6ba6e
movsd (%rsi), %xmm0
movsd %xmm0, (%rbx)
jmp 0x6ba6e
movq (%rsi), %r14
movl $0x30, %edi
callq 0xe250
movq %rax, (%rbx)
leaq 0x6(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x803c4
jmp 0x6ba6e
movq (%rsi), %r14
movl $0x18, %edi
callq 0xe250
movq %rax, (%rbx)
leaq 0x7(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x805fe
jmp 0x6ba6e
movb (%rsi), %al
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/src/json/json.node-time.native.cxx
// Function: test::kind::time_cxon_native(test::test&)
void time_cxon_native(test& t) {
        auto i = native::executors_.find(t.source.substr(t.source.rfind('/') + 1));
        i != native::executors_.end() ?
            i->second(t) :
            (time_cxon_node(t), t.flag = true, void())
        ;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0xe440
leaq 0x1(%rax), %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0xe270
leaq 0x729eb(%rip), %rdi     # 0x1266a0
movq %r14, %rsi
callq 0xd455c
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb3cd3
callq 0xe240
leaq 0x729ce(%rip), %rax     # 0x1266a8
cmpq %rax, %r14
je 0xb3ce8
movq %rbx, %rdi
callq *0x40(%r14)
jmp 0xb3cf4
movq %rbx, %rdi
callq 0xd45c4
movb $0x1, 0x78(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb3d12
callq 0xe240
movq %rbx, %rdi
callq 0xe3c0
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/readdisk.cc
// Function: main
int main(int argc, char *argv[])
{
  if (argc<4) { 
    usage();
    exit(-1);
  }
  SIZE_T blocknum=atoi(argv[2]);
  SIZE_T numblocks=atoi(argv[3]);
  double reqtime;

  DiskSystem disk(argv[1]);

  vector<Block> b;

  ERROR_T rc= disk.Read(blocknum, numblocks, b, reqtime);

  if (rc!=ERROR_NOERROR) { 
    cerr << "Error "<< rc << " occured.\n";
    return -1;
  } else {
    cerr << "Read took "<<reqtime<<" milliseconds\n";
    for (vector<Block>::const_iterator i=b.begin();i!=b.end();++i) {
      // cerr << (*i);
      for (SIZE_T j=0;j<(*i).length;j++) { 
	cout << (*i).data[j];
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
cmpl $0x3, %edi
jle 0x269d
movq %rsi, %r14
movq 0x10(%rsi), %rdi
callq 0x2290
movl %eax, %ebx
movq 0x18(%r14), %rdi
callq 0x2290
movl %eax, %ebp
movq 0x8(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x26f2
subq $0x8, %rsp
xorl %eax, %eax
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x2804
addq $0x20, %rsp
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2572
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2190
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %r8
movl %ebx, %esi
movl %ebp, %edx
callq 0x3584
movl %eax, %ebx
testl %eax, %eax
je 0x25e2
movq 0x5a4b(%rip), %rdi      # 0x7ff0
leaq 0x2a8c(%rip), %rsi      # 0x5038
movl $0x6, %edx
callq 0x21d0
movq 0x5a33(%rip), %rdi      # 0x7ff0
movl %ebx, %esi
callq 0x22f0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x2a6f(%rip), %rsi      # 0x503f
movl $0xa, %edx
movq %rax, %rdi
callq 0x21d0
jmp 0x2677
movq 0x5a07(%rip), %rdi      # 0x7ff0
leaq 0x2a5a(%rip), %rsi      # 0x504a
movl $0xa, %edx
callq 0x21d0
movsd 0x38(%rsp), %xmm0
movq 0x59e9(%rip), %rdi      # 0x7ff0
callq 0x22b0
leaq 0x2a42(%rip), %rsi      # 0x5055
movl $0xe, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x10(%rsp), %r15
cmpq 0x18(%rsp), %r15
je 0x2675
movq 0x599d(%rip), %rbx      # 0x7fd0
leaq 0xf(%rsp), %r14
cmpl $0x0, 0x10(%r15)
je 0x266a
xorl %r12d, %r12d
movq 0x8(%r15), %rax
movb (%rax,%r12), %al
movb %al, 0xf(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
incq %r12
movl 0x10(%r15), %eax
cmpq %rax, %r12
jb 0x2642
addq $0x28, %r15
cmpq 0x18(%rsp), %r15
jne 0x2638
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x2730
leaq 0x40(%rsp), %rdi
callq 0x2da4
movl %ebx, %eax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x24cc
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26ea
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x26ea
movq %rax, %rbx
jmp 0x26ea
jmp 0x26d3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2730
leaq 0x40(%rsp), %rdi
callq 0x2da4
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/lemire[P]runningmaxmin/./runningmaxmin.h
// Function: slowmaxmin::slowmaxmin(std::vector<double, std::allocator<double>>&, int)
slowmaxmin(std::vector<floattype> & array, int width)
        : maxvalues(array.size() - width + 1),
          minvalues(array.size() - width + 1) {
        floattype maxvalue, minvalue;
        for (uint s = 0; s < array.size() - width + 1; ++s) {
            maxvalue = array[s];
            minvalue = array[s];
            // could be done with iterators
            for (uint k = s + 1; k < s + width; ++k) {
                if (maxvalue < array[k])
                    maxvalue = array[k];
                if (minvalue > array[k])
                    minvalue = array[k];
            }
            maxvalues[s] = maxvalue;
            minvalues[s] = minvalue;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x7648(%rip), %rax      # 0xab68
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %r15
movq 0x8(%rsi), %rsi
subq (%r12), %rsi
sarq $0x3, %rsi
movslq %edx, %r13
subq %r13, %rsi
incq %rsi
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x555c
movq 0x8(%r12), %rsi
subq (%r12), %rsi
addq $0x20, %r14
sarq $0x3, %rsi
subq %r13, %rsi
incq %rsi
leaq 0xe(%rsp), %rdx
movq %r14, %rdi
callq 0x555c
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
subq %r13, %rcx
incq %rcx
je 0x35f2
movq (%r15), %rdx
movq (%r14), %rsi
leal -0x1(%rbx), %edi
movl $0x1, %r8d
xorl %r9d, %r9d
vmovsd (%rax,%r9,8), %xmm0
leaq 0x1(%r9), %r10
leal (%r9,%rbx), %r11d
cmpl %r10d, %r11d
jbe 0x35d4
movl %r8d, %r11d
leaq (%rax,%r11,8), %r11
xorl %r14d, %r14d
vmovapd %xmm0, %xmm1
vmovsd (%r11,%r14,8), %xmm2
vmaxsd %xmm1, %xmm2, %xmm1
vminsd %xmm0, %xmm2, %xmm0
incq %r14
cmpl %r14d, %edi
jne 0x35bc
jmp 0x35d8
vmovapd %xmm0, %xmm1
vmovsd %xmm1, (%rdx,%r9,8)
vmovsd %xmm0, (%rsi,%r9,8)
movl %r10d, %r11d
incl %r8d
movq %r10, %r9
cmpq %r11, %rcx
ja 0x359b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3610
callq 0x20e0
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/lemire[P]runningmaxmin/./runningmaxmin.h
// Function: lemiremaxminwrap::lemiremaxminwrap(std::vector<double, std::allocator<double>>&, unsigned int)
lemiremaxminwrap(std::vector<floattype> & array, uint width)
        : maxvalues(array.size() - width + 1),
          minvalues(array.size() - width + 1) {
        lemiremaxmintruestreaming lts(width);
        for (uint i = 0; i < width - 1; ++i) {
            lts.update(array[i]);
        }
        for (uint i = width - 1; i < array.size(); ++i) {
            lts.update(array[i]);
            maxvalues[i - width + 1] = lts.max();
            minvalues[i - width + 1] = lts.min();
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
leaq 0x6dfa(%rip), %rax      # 0xac08
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq 0x8(%rsi), %rsi
subq (%r12), %rsi
sarq $0x3, %rsi
movl %edx, %ebx
subq %rbx, %rsi
incq %rsi
leaq 0x10(%rsp), %rdx
movq %rdi, 0x8(%rsp)
callq 0x555c
movq 0x8(%r12), %rsi
subq (%r12), %rsi
addq $0x20, %r14
sarq $0x3, %rsi
subq %rbx, %rsi
incq %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x555c
leaq 0x10(%rsp), %rdi
movl %r15d, %esi
callq 0x5aa4
movl %r15d, %eax
decl %eax
movl %eax, %ebp
je 0x3e96
xorl %ebx, %ebx
leaq 0x10(%rsp), %r13
movq (%r12), %rax
vmovsd (%rax,%rbx,8), %xmm0
movq %r13, %rdi
callq 0x5b26
incq %rbx
cmpq %rbx, %rbp
jne 0x3e7d
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
jbe 0x3f17
xorl %ebx, %ebx
leaq 0x10(%rsp), %r13
vmovsd (%rax,%rbp,8), %xmm0
movq %r13, %rdi
callq 0x5b26
movq 0x10(%rsp), %rax
movl 0x18(%rsp), %ecx
shlq $0x4, %rcx
vmovsd 0x8(%rax,%rcx), %xmm0
movl %ebx, %eax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
vmovsd %xmm0, (%rcx,%rax,8)
movq 0x28(%rsp), %rcx
movl 0x30(%rsp), %edx
shlq $0x4, %rdx
vmovsd 0x8(%rcx,%rdx), %xmm0
movq (%r14), %rcx
vmovsd %xmm0, (%rcx,%rax,8)
leal (%r15,%rbx), %ebp
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebx
cmpq %rbp, %rcx
ja 0x3eb2
movq 0x10(%rsp), %rdi
callq 0x2120
movq 0x28(%rsp), %rdi
callq 0x2120
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x3f5d
movq %rax, %r15
jmp 0x3f6a
jmp 0x3f46
movq %rax, %r15
movq 0x10(%rsp), %rdi
callq 0x2120
movq 0x28(%rsp), %rdi
callq 0x2120
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3f6a
callq 0x20e0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3f7c
callq 0x20e0
movq %r15, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/lemire[P]runningmaxmin/./mono_wedge.h
// Function: void mono_wedge::mono_wedge_update<std::deque<Sample, std::allocator<Sample>>, Sample, std::greater<Sample>>(std::deque<Sample, std::allocator<Sample>>&, Sample const&, std::greater<Sample>)
void mono_wedge_update(
		Wedge   &wedge,
		const T &value,
		Compare  comp)
	{
		wedge.erase(
			mono_wedge_search(wedge.begin(), wedge.end(), value, comp),
			wedge.end());
		wedge.push_back(value);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
vmovups 0x10(%rdi), %ymm0
leaq 0x40(%rsp), %rsi
vmovups %ymm0, (%rsi)
vmovups 0x30(%rdi), %ymm0
leaq 0x20(%rsp), %rdx
vmovups %ymm0, (%rdx)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
vzeroupper
callq 0x65e9
movq (%r15), %rax
movq 0x18(%r15), %rcx
movq 0x30(%rbx), %rsi
movq 0x48(%rbx), %rdi
leaq 0xa0(%rsp), %rdx
movq %rax, (%rdx)
movq (%rcx), %rax
movq %rax, 0x8(%rdx)
movl $0x200, %r8d            # imm = 0x200
addq %r8, %rax
movq %rax, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
leaq 0x80(%rsp), %rcx
movq %rsi, (%rcx)
movq (%rdi), %rax
movq %rax, 0x8(%rcx)
addq %r8, %rax
movq %rax, 0x10(%rcx)
movq %rdi, 0x18(%rcx)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x680c
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
je 0x65d1
vmovups (%r14), %xmm0
vmovups %xmm0, (%rax)
addq $0x10, 0x30(%rbx)
jmp 0x65dc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7132
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/common/stringtokenizer.cc
// Function: StringTokenizer::getNext()
StringRef StringTokenizer::getNext(){
	size_t start = pos_;

	while(hasNext() && line_[pos_] != delimiter_)
		++pos_;

	size_t size = pos_ - start;

	StringRef s{ &line_[start], size };

	while(hasNext() && line_[pos_] == delimiter_)
		++pos_;

	return s;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rcx, %rax
cmpq %rdx, %rcx
jae 0x170e
movq 0x10(%rdi), %rsi
movb 0x18(%rdi), %r8b
movq %rcx, %rax
cmpb %r8b, (%rsi,%rax)
je 0x170e
incq %rax
movq %rax, (%rdi)
cmpq %rax, %rdx
jne 0x16fa
movq %rdx, %rax
movq (%rdi), %r8
movq 0x10(%rdi), %rsi
cmpq %rdx, %r8
jae 0x173e
movb 0x18(%rdi), %r9b
negq %rdx
incq %r8
cmpb %r9b, -0x1(%rsi,%r8)
jne 0x173e
movq %r8, (%rdi)
leaq (%rdx,%r8), %r10
incq %r10
incq %r8
cmpq $0x1, %r10
jne 0x1724
leaq (%rsi,%rcx), %rdi
testq %rsi, %rsi
leaq 0x988(%rip), %rdx       # 0x20d4
cmovneq %rdi, %rdx
subq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, (%rsi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq %rax, 0x8(%rsi)
je 0x17b8
movq %rsi, %r14
movq %rsp, %r15
movq %r14, %rdi
callq 0x16e0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x17a4
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x17af
movq %rbx, %rdi
movq %r15, %rdx
callq 0x17e4
movq (%r14), %rax
cmpq 0x8(%r14), %rax
jb 0x177b
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17dc
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1090
movq %r14, %rdi
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x960d
movq %rsi, %rbx
movl %edi, %r14d
leal -0x1(%r14), %eax
movl %eax, 0x4(%rsp)
leal -0x4(%r14), %eax
movl %eax, (%rsp)
movl $0x1, %ebp
leaq 0x3bb3(%rip), %r12      # 0xd0f5
leaq 0x3a63(%rip), %r13      # 0xcfac
movslq %ebp, %rax
movq (%rbx,%rax,8), %r15
movq %r15, %rdi
leaq 0x3b98(%rip), %rsi      # 0xd0f2
callq 0x2280
testl %eax, %eax
je 0x961c
movq %r15, %rdi
movq %r12, %rsi
callq 0x2280
testl %eax, %eax
je 0x961c
movq %r15, %rdi
movq %r13, %rsi
callq 0x2280
testl %eax, %eax
je 0x95da
movq %r15, %rdi
leaq 0x3b69(%rip), %rsi      # 0xd0fc
callq 0x2280
testl %eax, %eax
je 0x95da
movq %r15, %rdi
leaq 0x3b62(%rip), %rsi      # 0xd108
callq 0x2280
testl %eax, %eax
je 0x95e3
movq %r15, %rdi
leaq 0x3b52(%rip), %rsi      # 0xd10b
callq 0x2280
testl %eax, %eax
je 0x95e3
cmpl 0x4(%rsp), %ebp
jge 0x95ec
movl %ebp, %edi
movq %rbx, %rsi
callq 0x90ae
testb %al, %al
je 0x95ec
incl %ebp
jmp 0x9602
movb $0x1, 0x8c97(%rip)      # 0x12278
jmp 0x9602
movb $0x1, 0x8c8f(%rip)      # 0x12279
jmp 0x9602
cmpl (%rsp), %ebp
jge 0x962b
movl %ebp, %edi
movq %rbx, %rsi
callq 0x9273
testb %al, %al
je 0x962b
addl $0x4, %ebp
incl %ebp
cmpl %r14d, %ebp
jl 0x9549
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
callq 0x871c
xorl %edi, %edi
callq 0x2210
movq 0x89a6(%rip), %rdi      # 0x11fd8
leaq 0x3adc(%rip), %rsi      # 0xd115
callq 0x21b0
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x20d0
movq (%rbx), %rdi
callq 0x871c
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x9679
xorl %eax, %eax
cmpl $0x100, (%rdi,%rax,4)   # imm = 0x100
jae 0x967a
incq %rax
cmpq $0x4, %rax
jne 0x9667
retq
pushq %rax
movq 0x8956(%rip), %rdi      # 0x11fd8
leaq 0x3a9e(%rip), %rsi      # 0xd127
callq 0x21b0
movq %rax, %rdi
callq 0x20d0
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movq 0x8c18(%rip), %rdi      # 0x122c0
callq 0x9660
movq 0x8c14(%rip), %rdi      # 0x122c8
callq 0x9660
movq 0x8c10(%rip), %rdi      # 0x122d0
callq 0x9660
movq 0x8c0c(%rip), %rdi      # 0x122d8
callq 0x9660
movq 0x8c08(%rip), %rdi      # 0x122e0
callq 0x9660
movq 0x8c04(%rip), %rdi      # 0x122e8
callq 0x9660
movq 0x8c00(%rip), %rdi      # 0x122f0
callq 0x9660
movq 0x8bfc(%rip), %rdi      # 0x122f8
callq 0x9660
cmpl $0x100, 0x8b95(%rip)    # imm = 0x100
jae 0x9734
movl 0x8aed(%rip), %eax      # 0x12200
addl $-0x21, %eax
cmpl $-0x21, %eax
jbe 0x9744
movq 0x8b5e(%rip), %rdi      # 0x12280
testq %rdi, %rdi
je 0x9732
callq 0x20c0
cmpq $0x21, %rax
jae 0x9754
popq %rax
retq
movq 0x889d(%rip), %rdi      # 0x11fd8
leaq 0x3a14(%rip), %rsi      # 0xd156
jmp 0x9762
movq 0x888d(%rip), %rdi      # 0x11fd8
leaq 0x3a35(%rip), %rsi      # 0xd187
jmp 0x9762
movq 0x887d(%rip), %rdi      # 0x11fd8
leaq 0x3a3e(%rip), %rsi      # 0xd1a0
callq 0x21b0
movq %rax, %rdi
callq 0x20d0
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x7987(%rip)      # 0x12279
jne 0xa967
movq 0x76dd(%rip), %r14      # 0x11fd8
leaq 0x2ad4(%rip), %rsi      # 0xd3d6
movl $0x1b, %edx
movq %r14, %rdi
callq 0x21f0
movq 0x795a(%rip), %r15      # 0x12270
testq %r15, %r15
je 0xa937
movq %r15, %rdi
callq 0x20c0
movq 0x76ae(%rip), %rdi      # 0x11fd8
movq %r15, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0xa94f
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2310
movq 0x7682(%rip), %rdi      # 0x11fd8
leaq 0x2a95(%rip), %rsi      # 0xd3f2
movl $0x4, %edx
callq 0x21f0
movq 0x7902(%rip), %rsi      # 0x12270
movq %rbx, %rdi
callq 0x562e
cmpb $0x1, 0x78fc(%rip)      # 0x12279
jne 0xa9c1
movq 0x7652(%rip), %rbx      # 0x11fd8
leaq 0x28d1(%rip), %rsi      # 0xd25e
movl $0x5, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xaa64
movq %rbx, %rdi
callq 0x2230
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x860a
movq %rbx, %rdi
callq 0x20b0
movq 0x75dd(%rip), %rdi      # 0x11fd8
leaq 0x29f5(%rip), %rsi      # 0xd3f7
movl $0x14, %edx
callq 0x21f0
movq 0x785d(%rip), %rsi      # 0x12270
movq 0x75be(%rip), %rdi      # 0x11fd8
callq 0x21b0
movq %rax, %rbx
leaq 0x286d(%rip), %rsi      # 0xd296
movl $0x1, %edx
movq %rax, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x20d0
leaq 0x8(%rsp), %rdi
callq 0x8624
callq 0x2300
jmp 0xa976
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8624
callq 0x2300
movq %rbx, %rdi
callq 0x2350
movq %rax, %rdi
callq 0x7292
// File: /workspace/github_cpp_makefile_star2_O1/ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: Cleanup()
void Cleanup()
{
	if(title_string)       { delete[] title_string;              title_string = NULL; }
	if(icon_string)        { delete[] icon_string;                icon_string = NULL; }
	if(icon_copy_string)   { delete[] icon_copy_string;      icon_copy_string = NULL; }
	if(icon_delete_string) { delete[] icon_delete_string;  icon_delete_string = NULL; }
	if(light1_dir)         { delete[] light1_dir;                  light1_dir = NULL; }
	if(light2_dir)         { delete[] light2_dir;                  light2_dir = NULL; }
	if(light3_dir)         { delete[] light3_dir;                  light3_dir = NULL; }
	if(light1_color)       { delete[] light1_color;              light1_color = NULL; }
	if(light2_color)       { delete[] light2_color;              light2_color = NULL; }
	if(light3_color)       { delete[] light3_color;              light3_color = NULL; }
	if(ambient_color)      { delete[] ambient_color;            ambient_color = NULL; }
	if(bg_color_ul)        { delete[] bg_color_ul;                bg_color_ul = NULL; }
	if(bg_color_ur)        { delete[] bg_color_ur;                bg_color_ur = NULL; }
	if(bg_color_ll)        { delete[] bg_color_ll;                bg_color_ll = NULL; }
	if(bg_color_lr)        { delete[] bg_color_lr;                bg_color_lr = NULL; }
}

// Assembly:
pushq %rax
movq 0x7804(%rip), %rdi      # 0x12280
testq %rdi, %rdi
je 0xaa91
callq 0x2250
movq $0x0, 0x77ef(%rip) # 0x12280
movq 0x77f0(%rip), %rdi      # 0x12288
testq %rdi, %rdi
je 0xaaad
callq 0x2250
movq $0x0, 0x77db(%rip) # 0x12288
movq 0x77dc(%rip), %rdi      # 0x12290
testq %rdi, %rdi
je 0xaac9
callq 0x2250
movq $0x0, 0x77c7(%rip) # 0x12290
movq 0x77c8(%rip), %rdi      # 0x12298
testq %rdi, %rdi
je 0xaae5
callq 0x2250
movq $0x0, 0x77b3(%rip) # 0x12298
movq 0x77bc(%rip), %rdi      # 0x122a8
testq %rdi, %rdi
je 0xab01
callq 0x2250
movq $0x0, 0x77a7(%rip) # 0x122a8
movq 0x77a8(%rip), %rdi      # 0x122b0
testq %rdi, %rdi
je 0xab1d
callq 0x2250
movq $0x0, 0x7793(%rip) # 0x122b0
movq 0x7794(%rip), %rdi      # 0x122b8
testq %rdi, %rdi
je 0xab39
callq 0x2250
movq $0x0, 0x777f(%rip) # 0x122b8
movq 0x7780(%rip), %rdi      # 0x122c0
testq %rdi, %rdi
je 0xab55
callq 0x2250
movq $0x0, 0x776b(%rip) # 0x122c0
movq 0x776c(%rip), %rdi      # 0x122c8
testq %rdi, %rdi
je 0xab71
callq 0x2250
movq $0x0, 0x7757(%rip) # 0x122c8
movq 0x7758(%rip), %rdi      # 0x122d0
testq %rdi, %rdi
je 0xab8d
callq 0x2250
movq $0x0, 0x7743(%rip) # 0x122d0
movq 0x7744(%rip), %rdi      # 0x122d8
testq %rdi, %rdi
je 0xaba9
callq 0x2250
movq $0x0, 0x772f(%rip) # 0x122d8
movq 0x7730(%rip), %rdi      # 0x122e0
testq %rdi, %rdi
je 0xabc5
callq 0x2250
movq $0x0, 0x771b(%rip) # 0x122e0
movq 0x771c(%rip), %rdi      # 0x122e8
testq %rdi, %rdi
je 0xabe1
callq 0x2250
movq $0x0, 0x7707(%rip) # 0x122e8
movq 0x7708(%rip), %rdi      # 0x122f0
testq %rdi, %rdi
je 0xabfd
callq 0x2250
movq $0x0, 0x76f3(%rip) # 0x122f0
movq 0x76f4(%rip), %rdi      # 0x122f8
testq %rdi, %rdi
je 0xac19
callq 0x2250
movq $0x0, 0x76df(%rip) # 0x122f8
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7094(%rip), %r14      # 0x11fd8
movq (%r14), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r14,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r15
cmpb $0x0, 0xe1(%r14,%rax)
jne 0xaf8a
movq %r15, %rdi
movl $0x20, %esi
callq 0x2190
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
leaq 0x2511(%rip), %rsi      # 0xd4aa
movl $0x2, %r12d
movl $0x2, %edx
movq %r14, %rdi
callq 0x21f0
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x583e
movq %r14, %rdi
movl %eax, %esi
callq 0x2330
movq %rax, %r15
leaq 0x24d4(%rip), %r14      # 0xd4a8
movl $0x4, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq %rbx, %rdi
callq 0x584e
movq %r15, %rdi
movl %eax, %esi
callq 0x2330
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq %rbx, %rdi
callq 0x585e
movq %r15, %rdi
movl %eax, %esi
callq 0x2330
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq %rbx, %rdi
callq 0x586e
movq %r15, %rdi
movl %eax, %esi
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r14
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0xb0aa
movq %r14, %rdi
movl $0x20, %esi
callq 0x2190
movb %al, 0xe0(%r14)
movb $0x1, 0xe1(%r14)
movb $0x20, 0xe0(%r14)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movapd 0x8(%rsp), %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
maxsd %xmm0, %xmm3
movsd 0x18(%rsp), %xmm1
movapd %xmm1, %xmm2
maxsd %xmm3, %xmm2
ucomisd 0x67b1(%rip), %xmm2     # 0xd060
jbe 0x68d3
movsd 0x67a7(%rip), %xmm3     # 0xd060
divsd %xmm2, %xmm3
mulsd %xmm3, %xmm1
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm3, %xmm0
movupd %xmm0, (%rax)
movsd %xmm1, 0x10(%rax)
retq
leaq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movl %edx, %ebp
movq %rsi, %rbx
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movl $0x2, %edx
callq 0x9af6
movq %r14, %rdi
callq 0x4130
testq %rax, %rax
setne %cl
cmpq $-0x1, %rdx
setne %sil
andb %cl, %sil
cmpb $0x1, %sil
jne 0x6975
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
movq $-0x1, %rcx
callq 0x4300
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x2, %edx
callq 0xa79e
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x697f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x697f
leaq 0x50(%rsp), %rdi
callq 0xa842
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0xa8fa
leaq 0x50(%rsp), %rdi
callq 0x9b7e
leaq 0x78(%rsp), %rdi
callq 0x9b7e
leaq 0x6886(%rip), %rsi      # 0xd240
leaq 0x10(%rsp), %rdi
callq 0x40c0
testl %eax, %eax
je 0x6a12
leaq 0x6876(%rip), %rsi      # 0xd245
leaq 0x10(%rsp), %rdi
callq 0x40c0
testl %eax, %eax
je 0x6a12
leaq 0x68fd(%rip), %rsi      # 0xd2e1
leaq 0x10(%rsp), %rdi
callq 0x40c0
testl %eax, %eax
je 0x6a48
leaq 0x6852(%rip), %rsi      # 0xd24b
leaq 0x10(%rsp), %rdi
callq 0x40c0
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xa089
jmp 0x6a21
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x9bb6
movl %eax, %ebx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x6a3a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x9dab
jmp 0x6a21
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6aa5
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x6aa5
movq %rax, %rbx
jmp 0x6aa5
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x6aaf
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x6aaf
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x9b7e
leaq 0x78(%rsp), %rdi
callq 0x9b7e
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
subq $0x20, %rsp
movapd %xmm0, %xmm2
movsd 0x65a8(%rip), %xmm0     # 0xd070
minsd %xmm2, %xmm0
divsd 0x65a4(%rip), %xmm0     # 0xd078
cmpltsd 0x65a3(%rip), %xmm2     # 0xd080
movq %rdi, %rbx
movsd 0x65a0(%rip), %xmm1     # 0xd088
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movsd 0x6594(%rip), %xmm1     # 0xd090
ucomisd %xmm2, %xmm1
movapd %xmm2, (%rsp)
jb 0x6b11
movsd 0x6551(%rip), %xmm0     # 0xd060
jmp 0x6b58
movsd 0x657f(%rip), %xmm0     # 0xd098
addsd %xmm2, %xmm0
movsd 0x657b(%rip), %xmm1     # 0xd0a0
callq 0x44f0
movapd (%rsp), %xmm2
mulsd 0x6571(%rip), %xmm0     # 0xd0a8
movsd 0x6521(%rip), %xmm3     # 0xd060
minsd %xmm0, %xmm3
xorpd %xmm1, %xmm1
cmpltsd %xmm1, %xmm0
movsd 0x653c(%rip), %xmm1     # 0xd090
andnpd %xmm3, %xmm0
movapd %xmm0, 0x10(%rsp)
ucomisd %xmm2, %xmm1
jb 0x6b83
movapd %xmm2, %xmm0
callq 0x4250
movapd %xmm0, %xmm3
mulsd 0x6547(%rip), %xmm3     # 0xd0c0
addsd 0x6547(%rip), %xmm3     # 0xd0c8
jmp 0x6ba8
movsd 0x650d(%rip), %xmm0     # 0xd098
addsd %xmm2, %xmm0
movsd 0x6519(%rip), %xmm1     # 0xd0b0
callq 0x44f0
movapd %xmm0, %xmm3
mulsd 0x6510(%rip), %xmm3     # 0xd0b8
movsd 0x64b0(%rip), %xmm4     # 0xd060
movapd (%rsp), %xmm2
ucomisd 0x64d3(%rip), %xmm2     # 0xd090
movapd %xmm4, %xmm0
jae 0x6c21
xorpd %xmm0, %xmm0
movsd 0x6501(%rip), %xmm1     # 0xd0d0
ucomisd %xmm2, %xmm1
jae 0x6c21
movsd 0x64fb(%rip), %xmm0     # 0xd0d8
addsd %xmm2, %xmm0
movapd %xmm3, (%rsp)
callq 0x4250
movsd 0x646d(%rip), %xmm4     # 0xd060
movapd (%rsp), %xmm3
mulsd 0x64e0(%rip), %xmm0     # 0xd0e0
addsd 0x64e0(%rip), %xmm0     # 0xd0e8
movsd 0x6450(%rip), %xmm1     # 0xd060
minsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
cmpltsd %xmm2, %xmm0
andnpd %xmm1, %xmm0
minsd %xmm3, %xmm4
xorpd %xmm1, %xmm1
cmpltsd %xmm1, %xmm3
andnpd %xmm4, %xmm3
movaps 0x10(%rsp), %xmm1
movsd %xmm1, (%rbx)
movlpd %xmm3, 0x8(%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movss %xmm1, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
movaps %xmm1, %xmm0
callq 0x4210
movss %xmm0, 0x10(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x4270
mulss 0x10(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movss 0x8(%rsp), %xmm0
callq 0x4270
movaps %xmm0, 0x20(%rsp)
movss 0x8(%rsp), %xmm0
callq 0x4210
movss %xmm0, 0x8(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x4210
mulss 0x8(%rsp), %xmm0
movaps 0x10(%rsp), %xmm2
unpcklps 0x20(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
movaps 0x64db(%rip), %xmm1     # 0xd1a0
movss %xmm0, %xmm1            # xmm1 = xmm0[0],xmm1[1,2,3]
movaps %xmm2, %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movss %xmm1, (%rsp)
movss %xmm0, 0x10(%rsp)
movaps %xmm1, %xmm0
callq 0x4210
movss %xmm0, 0x20(%rsp)
movss 0x10(%rsp), %xmm0
callq 0x4270
mulss 0x20(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movss (%rsp), %xmm0
callq 0x4270
movaps %xmm0, 0x30(%rsp)
movss (%rsp), %xmm0
callq 0x4210
movss %xmm0, (%rsp)
movss 0x10(%rsp), %xmm0
callq 0x4210
mulss (%rsp), %xmm0
movaps 0x20(%rsp), %xmm2
unpcklps 0x30(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
movaps 0x63d6(%rip), %xmm1     # 0xd1a0
movss %xmm0, %xmm1            # xmm1 = xmm0[0],xmm1[1,2,3]
movlhps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
leaq 0x40(%rsp), %rsi
movups %xmm2, (%rsi)
movq %rbx, %rdi
callq 0xa2ae
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movaps %xmm2, 0x10(%rsp)
xorps 0x63bc(%rip), %xmm0     # 0xd1b0
callq 0x43c0
movaps %xmm0, (%rsp)
movaps 0x10(%rsp), %xmm0
callq 0x4480
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtps2pd %xmm1, %xmm0
mulpd 0x63a7(%rip), %xmm0     # 0xd1c0
cvtpd2ps %xmm0, %xmm0
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rax
divsd 0x62c4(%rip), %xmm0     # 0xd0f0
addsd 0x62c4(%rip), %xmm0     # 0xd0f8
movapd %xmm0, %xmm1
divsd 0x62c0(%rip), %xmm1     # 0xd100
movsd %xmm1, (%rsp)
movsd 0x6213(%rip), %xmm1     # 0xd060
callq 0x4390
movsd 0x62ae(%rip), %xmm1     # 0xd108
movsd (%rsp), %xmm2
mulsd %xmm2, %xmm1
addsd 0x62a5(%rip), %xmm1     # 0xd110
mulsd %xmm2, %xmm1
addsd 0x62a1(%rip), %xmm1     # 0xd118
mulsd %xmm2, %xmm1
addsd 0x629d(%rip), %xmm1     # 0xd120
mulsd 0x6265(%rip), %xmm0     # 0xd0f0
addsd %xmm1, %xmm0
mulsd 0x6291(%rip), %xmm0     # 0xd128
movsd 0x6291(%rip), %xmm1     # 0xd130
callq 0x4390
movsd 0x6284(%rip), %xmm3     # 0xd130
addsd %xmm0, %xmm3
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm1
cmpltsd %xmm2, %xmm1
andpd %xmm1, %xmm3
andnpd %xmm0, %xmm1
orpd %xmm3, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movsd %xmm3, 0x10(%rsp)
cvtsd2ss %xmm2, %xmm2
cvtsd2ss %xmm0, %xmm0
movq %rdi, %rbx
xorps %xmm3, %xmm3
cvtsd2ss %xmm1, %xmm3
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
mulsd 0x5e76(%rip), %xmm1     # 0xd138
cvtsd2ss %xmm1, %xmm1
divss %xmm0, %xmm3
movss %xmm3, 0xc(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x5e79(%rip), %xmm0     # 0xd158
callq 0x41a0
movsd 0x10(%rsp), %xmm2
movsd 0x5d6e(%rip), %xmm1     # 0xd060
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss 0xc(%rsp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rbx)
movss %xmm1, 0x14(%rbx)
movups %xmm0, 0x18(%rbx)
movsd 0x5ed0(%rip), %xmm1     # 0xd1f0
movups %xmm1, 0x28(%rbx)
movss 0x5ce0(%rip), %xmm1     # 0xd00c
movlpd %xmm1, 0x38(%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x733d
jnp 0x73aa
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
xorps 0x5e65(%rip), %xmm1     # 0xd1b0
movl $0x3f800000, %eax       # imm = 0x3F800000
leaq 0x18(%rsp), %rdx
movl %eax, (%rdx)
movups %xmm0, 0x4(%rdx)
movl %eax, 0x14(%rdx)
movups %xmm0, 0x18(%rdx)
movss 0x5ca6(%rip), %xmm0     # 0xd010
movups %xmm0, 0x28(%rdx)
movss %xmm1, 0x38(%rdx)
movl %eax, 0x3c(%rdx)
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa2f6
movups (%r14), %xmm0
movupd 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movupd %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rdx
cmpq $0x2, %rdi
jb 0x7514
cmpb $0x4d, (%rsi)
jne 0x7514
leaq 0x1(%rsi), %rax
addq %rsi, %rdx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xa86a
movq 0x8(%rsp), %rbx
callq 0x4040
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
cmpq %rbx, (%r15)
je 0x75c6
movaps %xmm0, %xmm1
movl (%r14), %eax
testl %eax, %eax
je 0x7572
cmpl $0x22, %eax
jne 0x7575
leaq 0x6034(%rip), %rdi      # 0xd543
callq 0x4410
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xa86a
movq 0x8(%rsp), %rbx
callq 0x4040
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
cmpq %rbx, (%r15)
je 0x75ba
movl (%r14), %eax
testl %eax, %eax
je 0x756d
cmpl $0x22, %eax
jne 0x758a
leaq 0x5fdb(%rip), %rdi      # 0xd543
callq 0x4410
movl %ebp, (%r14)
jmp 0x758a
movl %ebp, (%r14)
mulss 0x5a87(%rip), %xmm1     # 0xd004
movss 0x5a83(%rip), %xmm0     # 0xd008
callq 0x4470
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x75ad
movq 0x18(%rsp), %rsi
incq %rsi
movss %xmm0, 0x4(%rsp)
callq 0x42e0
movss 0x4(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f82(%rip), %rdi      # 0xd543
callq 0x41c0
leaq 0x5f76(%rip), %rdi      # 0xd543
callq 0x41c0
jmp 0x75d6
jmp 0x75db
movq %rax, %rbx
jmp 0x75fe
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x75e7
movl %ebp, (%r14)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x75fe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x5, %rdi
je 0x7644
cmpq $0x4, %rbx
jne 0x765e
leaq 0x5c25(%rip), %rsi      # 0xd250
movq %r14, %rdi
movq %rbx, %rdx
callq 0x42f0
testl %eax, %eax
je 0x76e2
cmpq $0x5, %rbx
jne 0x765e
leaq 0x5c0a(%rip), %rsi      # 0xd255
movq %r14, %rdi
movq %rbx, %rdx
callq 0x42f0
testl %eax, %eax
je 0x76de
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
addq %r14, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa86a
movq (%r15), %r14
callq 0x4040
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x43e0
cmpq %r14, (%r15)
je 0x76f3
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x76ff
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0x76ff
testl %ecx, %ecx
jne 0x76c0
movl %ebp, (%rbx)
testl %eax, %eax
setne %bl
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x76e4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x76e4
xorl %ebx, %ebx
jmp 0x76e4
movb $0x1, %bl
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e44(%rip), %rdi      # 0xd53e
callq 0x41c0
leaq 0x5e38(%rip), %rdi      # 0xd53e
callq 0x4410
movq %rax, %r14
cmpl $0x0, (%rbx)
jne 0x7715
movl %ebp, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x772c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq 0xab5a(%rip), %r15      # 0x12300
movq 0xab5b(%rip), %rax      # 0x12308
movq %rax, (%rsp)
cmpq %rax, %r15
je 0x7825
leaq 0x8(%rsp), %r14
movq 0x10(%r15), %r12
movq 0x18(%r15), %r13
cmpq %r13, %r12
sete %bpl
je 0x7816
movq (%r12), %rdi
movq 0x8(%r12), %rsi
movq %r14, %rdx
callq 0xb5d1
cmpq 0x8(%r12), %rax
cmovneq %r12, %rbx
jne 0x7816
addq $0x30, %r12
cmpq %r13, %r12
sete %bpl
je 0x7816
movq (%r12), %rdi
movq 0x8(%r12), %rsi
movq %r14, %rdx
callq 0xb5d1
cmpq 0x8(%r12), %rax
cmovneq %r12, %rbx
leaq 0x30(%r12), %r12
je 0x77ec
testb %bpl, %bpl
je 0x7827
addq $0x28, %r15
cmpq (%rsp), %r15
jne 0x77bb
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r15
movq 0x18(%rsi), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r8, %rdx
movq %r9, %rcx
callq *0x10(%rax)
movq 0x28(%rbp), %rcx
movb $0x1, %al
cmpq $-0x1, %rcx
je 0x787d
movb $0x1, (%r15,%rcx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x7950
movq %r15, %rdi
callq 0x4120
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
addq %r13, %r12
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xa86a
movq 0x8(%rsp), %r15
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
addq %r14, %rbx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa86a
movq 0x28(%rsp), %rdx
leaq 0x5b74(%rip), %rdi      # 0xd45e
movq %r15, %rsi
callq 0x45b0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x7909
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7920
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
callq 0x4490
xorl %eax, %eax
jmp 0x787d
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x794b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x794b
movq %rax, %r15
callq 0x4490
movq %r15, %rdi
callq 0x4510
movq %rax, %rdi
callq 0xa5b8