LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
cmpq $0x7, %rax
ja 0x5ae22
leaq 0x62217(%rip), %rcx     # 0xbd020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
movq %rax, (%rdi)
retq
jmp 0x6d5e6
andq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
jmp 0x6d1f6
jmp 0x6d490
movb (%rsi), %al
movb %al, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x2f
popq %rsi
pushq $-0x1
popq %r14
movq %r14, %rdx
callq 0xe510
leaq 0x1(%rax), %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0xe2c0
leaq 0xa75c4(%rip), %rdi     # 0x13d700
movq %r15, %rsi
callq 0xb8d64
movq %rax, %r14
movq %rsp, %rdi
callq 0xe150
leaq 0xa75b2(%rip), %rax     # 0x13d708
cmpq %rax, %r14
je 0x96164
movq %rbx, %rdi
callq *0x40(%r14)
jmp 0x96170
movq %rbx, %rdi
callq 0xb8ddc
movb $0x1, 0x78(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe150
movq %rbx, %rdi
callq 0xe470
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xd0, %rsp
cmpl $0x3, %edi
jle 0x265c
movq %rsi, %r14
movq 0x10(%rsi), %rdi
callq 0x22b0
movl %eax, %ebx
movq 0x18(%r14), %rdi
callq 0x22b0
movl %eax, %ebp
movq 0x8(%r14), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x1f(%rsp), %rdx
callq 0x269e
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2800
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x20a0
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rcx
leaq 0x48(%rsp), %r8
movl %ebx, %esi
movl %ebp, %edx
callq 0x33a8
movl %eax, %ebx
testl %eax, %eax
je 0x25ef
movq 0x4a4f(%rip), %rdi      # 0x6ff0
leaq 0x1a90(%rip), %rsi      # 0x4038
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x2310
leaq 0x1a81(%rip), %rsi      # 0x403f
movq %rax, %rdi
callq 0x2170
pushq $-0x1
popq %rbx
leaq 0x20(%rsp), %rdi
callq 0x26da
leaq 0x50(%rsp), %rdi
callq 0x2c0e
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x49fa(%rip), %rdi      # 0x6ff0
leaq 0x1a4d(%rip), %rsi      # 0x404a
callq 0x2170
movsd 0x48(%rsp), %xmm0
movq %rax, %rdi
callq 0x22d0
leaq 0x1a3e(%rip), %rsi      # 0x4055
movq %rax, %rdi
callq 0x2170
movq 0x20(%rsp), %r15
xorl %ebx, %ebx
movq 0x49a3(%rip), %r14      # 0x6fd0
cmpq 0x28(%rsp), %r15
je 0x25c9
xorl %r12d, %r12d
movl 0x10(%r15), %eax
cmpq %rax, %r12
jae 0x2656
movq 0x8(%r15), %rax
movsbl (%rax,%r12), %esi
movq %r14, %rdi
callq 0x21e0
incq %r12
jmp 0x2637
addq $0x28, %r15
jmp 0x262d
callq 0x24dc
pushq $-0x1
popq %rdi
callq 0x2210
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20a0
jmp 0x2696
movq %rax, %rbx
jmp 0x2696
jmp 0x267f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x26da
leaq 0x50(%rsp), %rdi
callq 0x2c0e
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/testTemplateClass.cc
// Function: main
int main(int argc, const char* argv[]) {
	templateClass test;
	if (argc != 2) {
		cerr << "Please also put the tree file name" << endl;
		exit(1);
	}

	test.loadTree(argv[1]);

	while (1) {
		cout << "please input DNA string: " << endl;
		string DNA;
		cin >> DNA;

		cout << "please input number of thresholds: ";
		int input;
		cin >> input;
		
		cout << "please input thresholds, one by one:" << endl;

		vector<int> thresholds(input, 1);
		for (int i = 0; i < thresholds.size(); i++)
			cin >> thresholds[i];

		test.setThresholdVec(thresholds);
		test.analyzeRead(DNA);
		test.printInfo();
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp            # imm = 0x448
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x88(%rsp), %rdi
callq 0x3a94
cmpl $0x2, %ebp
jne 0x37c1
movq 0x8(%rbx), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x383e
leaq 0x88(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3b4a
leaq 0x48(%rsp), %rdi
callq 0x3110
movq 0xa92a(%rip), %rbx      # 0xdfc8
movq 0xa933(%rip), %r15      # 0xdfd8
leaq 0x28(%rsp), %rbp
leaq 0x88(%rsp), %r13
movq %rbx, %rdi
leaq 0x596b(%rip), %rsi      # 0x9027
callq 0x3210
movq %rax, %rdi
callq 0x3120
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x32d0
movq %rbx, %rdi
leaq 0x594e(%rip), %rsi      # 0x9041
callq 0x3210
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
callq 0x3160
movq %rbx, %rdi
leaq 0x5956(%rip), %rsi      # 0x9065
callq 0x3210
movq %rax, %rdi
callq 0x3120
movslq 0xc(%rsp), %rsi
movl $0x1, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x7(%rsp), %rcx
callq 0x387a
movq %rbx, %r14
xorl %ebx, %ebx
xorl %r12d, %r12d
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
subq %rsi, %rax
sarq $0x2, %rax
cmpq %r12, %rax
jbe 0x376f
addq %rbx, %rsi
movq %r15, %rdi
callq 0x3160
incq %r12
addq $0x4, %rbx
jmp 0x3745
movq %r13, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3b98
movq %r14, %rbx
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3340
movq %r13, %rdi
movq %r14, %rsi
callq 0x3bf6
movq %r14, %rdi
callq 0x3110
movq %r13, %rdi
callq 0x3d3e
leaq 0x10(%rsp), %rdi
callq 0x3916
movq %rbp, %rdi
callq 0x3110
jmp 0x36b2
movq 0xa828(%rip), %rdi      # 0xdff0
leaq 0x5835(%rip), %rsi      # 0x9004
callq 0x3210
movq %rax, %rdi
callq 0x3120
pushq $0x1
popq %rdi
callq 0x3290
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3110
jmp 0x3803
jmp 0x37fb
jmp 0x37fb
jmp 0x3825
jmp 0x3800
movq %rax, %rbx
jmp 0x380d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3916
leaq 0x28(%rsp), %rdi
jmp 0x381c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3110
jmp 0x3828
jmp 0x3825
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x38d0
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O2/hallboyone[P]Sandbox/test.cpp
// Function: main
int main(){
  Wrapper w(10);
  std::cout<<w.get()<<std::endl;
  int & num_ref = w.get();
  std::cout<<num_ref<<std::endl;
  w.set(15);
  std::cout<<w.get()<<std::endl;
  std::cout<<num_ref<<std::endl;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2e1e(%rip), %rbx      # 0x3fd8
pushq $0xa
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1060
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1060
movq %rax, %rdi
callq 0x1030
pushq $0xf
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1060
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1060
movq %rax, %rdi
callq 0x1030
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7e86(%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 0x4392
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 0x4392
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
subq %r13, %rcx
incq %rcx
movq (%r15), %rdx
movq (%r14), %rsi
xorl %r9d, %r9d
pushq $0x1
popq %rdi
movl %r9d, %r8d
cmpq %r8, %rcx
jbe 0x2d9a
movl %edi, %r9d
vmovsd (%rax,%r8,8), %xmm0
leal (%r8,%rbx), %r10d
vmovapd %xmm0, %xmm1
cmpq %r10, %r9
jae 0x2d86
vmovsd (%rax,%r9,8), %xmm2
vmaxsd %xmm0, %xmm2, %xmm0
vminsd %xmm1, %xmm2, %xmm1
incq %r9
jmp 0x2d6e
leal 0x1(%r8), %r9d
vmovsd %xmm0, (%rdx,%r8,8)
vmovsd %xmm1, (%rsi,%r8,8)
incl %edi
jmp 0x2d55
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x60f0
movq %rbx, %rdi
callq 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
leaq 0x7a4e(%rip), %rax      # 0xac08
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq 0x8(%rsi), %rsi
subq (%r12), %rsi
sarq $0x3, %rsi
movl %edx, %r13d
subq %r13, %rsi
incq %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x4392
movq 0x8(%r12), %rsi
subq (%r12), %rsi
addq $0x20, %r14
sarq $0x3, %rsi
subq %r13, %rsi
incq %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0x4392
movq %rsp, %rdi
movl %r15d, %esi
callq 0x4968
decl %r15d
xorl %ebp, %ebp
movq %rsp, %r13
cmpq %rbp, %r15
je 0x3235
movq (%r12), %rax
vmovsd (%rax,%rbp,8), %xmm0
movq %r13, %rdi
callq 0x499e
incq %rbp
jmp 0x321a
xorl %ebp, %ebp
movq %rsp, %r13
leal (%r15,%rbp), %eax
movq (%r12), %rcx
movq 0x8(%r12), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x329b
vmovsd (%rcx,%rax,8), %xmm0
movq %r13, %rdi
callq 0x499e
movq (%rsp), %rax
movl 0x8(%rsp), %ecx
shlq $0x4, %rcx
vmovsd 0x8(%rax,%rcx), %xmm0
movl %ebp, %eax
movq (%rbx), %rcx
vmovsd %xmm0, (%rcx,%rax,8)
movq 0x18(%rsp), %rcx
movl 0x20(%rsp), %edx
shlq $0x4, %rdx
vmovsd 0x8(%rcx,%rdx), %xmm0
movq (%r14), %rcx
vmovsd %xmm0, (%rcx,%rax,8)
incl %ebp
jmp 0x323a
movq %rsp, %rdi
callq 0x4a94
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x32c9
movq %rax, %r15
jmp 0x32d1
jmp 0x32be
movq %rax, %r15
movq %rsp, %rdi
callq 0x4a94
movq %r14, %rdi
callq 0x60f0
movq %rbx, %rdi
callq 0x60f0
movq %r15, %rdi
callq 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]runningmaxmin/./runningmaxmin.h
// Function: lemiremaxmintruestreaming::update(double)
void update(floattype value) {
        if (nonempty(&up) != 0) {
            if (value > tailvalue(&up)) {
                prunetail(&up);
                while (((nonempty(&up)) != 0) && (value >= tailvalue(&up))) {
                    prunetail(&up);
                }
            } else {
                prunetail(&lo);
                while (((nonempty(&lo)) != 0) && (value <= tailvalue(&lo))) {
                    prunetail(&lo);
                }
            }
        }
        push(&up, n, value);
        if (n == ww + headindex(&up)) {
            prunehead(&up);
        }

        push(&lo, n, value);
        if (n == ww + headindex(&lo)) {
            prunehead(&lo);
        }
        n++;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %edx
cmpl %eax, %edx
je 0x4a24
movq (%rbx), %rcx
decl %edx
movl 0x10(%rbx), %esi
andl %esi, %edx
movq %rdx, %rdi
shlq $0x4, %rdi
vucomisd 0x8(%rcx,%rdi), %xmm0
jbe 0x49e6
cmpl %eax, %edx
je 0x4a18
movl %edx, %edi
leal -0x1(%rdi), %edx
andl %esi, %edx
movq %rdx, %r8
shlq $0x4, %r8
vucomisd 0x8(%rcx,%r8), %xmm0
jae 0x49c9
jmp 0x4a1a
movl 0x24(%rbx), %edx
decl %edx
movl 0x28(%rbx), %eax
andl %eax, %edx
movl 0x20(%rbx), %ecx
movq 0x18(%rbx), %rdi
cmpl %ecx, %edx
je 0x4a1f
movl %edx, %esi
leal -0x1(%rsi), %edx
andl %eax, %edx
movq %rdx, %r8
shlq $0x4, %r8
vmovsd 0x8(%rdi,%r8), %xmm1
vucomisd %xmm0, %xmm1
jae 0x49f7
jmp 0x4a21
movl %eax, %edi
movl %edi, 0xc(%rbx)
jmp 0x4a24
movl %ecx, %esi
movl %esi, 0x24(%rbx)
movl 0x30(%rbx), %esi
movq %rbx, %rdi
vmovsd %xmm0, 0x8(%rsp)
callq 0x4b04
movl 0x30(%rbx), %esi
movq (%rbx), %rcx
movl 0x8(%rbx), %eax
movq %rax, %rdx
shlq $0x4, %rdx
movl (%rcx,%rdx), %ecx
addl 0x34(%rbx), %ecx
cmpl %ecx, %esi
jne 0x4a57
incl %eax
andl 0x10(%rbx), %eax
movl %eax, 0x8(%rbx)
leaq 0x18(%rbx), %rdi
vmovsd 0x8(%rsp), %xmm0
callq 0x4b04
movl 0x30(%rbx), %eax
movq 0x18(%rbx), %rdx
movl 0x20(%rbx), %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
movl (%rdx,%rsi), %edx
addl 0x34(%rbx), %edx
cmpl %edx, %eax
jne 0x4a89
incl %ecx
andl 0x28(%rbx), %ecx
movl %ecx, 0x20(%rbx)
incl %eax
movl %eax, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]runningmaxmin/./deque.h
// Function: init(intfloatqueue*, unsigned int)
inline void init(intfloatqueue * q, uint size) {
    size = nextPowerOfTwo(size + 1);
    q->nodes =
        reinterpret_cast<intfloatnode *>(malloc(sizeof(intfloatnode) * size));
    q->head = 0;
    q->tail = 0;
    q->mask = size - 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leal 0x1(%rsi), %edi
callq 0x4af7
movl %eax, %ebp
movl %eax, %edi
shlq $0x4, %rdi
callq 0x2100
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
decl %ebp
movl %ebp, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]runningmaxmin/./deque.h
// Function: nextPowerOfTwo(unsigned int)
inline uint nextPowerOfTwo(uint x) {
    uint result = 1;
    while (result < x) {
        result <<= 1;
    }
    return result;
}

// Assembly:
pushq $0x1
popq %rcx
movl %ecx, %eax
leal (%rax,%rax), %ecx
cmpl %edi, %eax
jb 0x4afa
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
vmovups 0x10(%rdi), %ymm0
leaq 0x60(%rsp), %rsi
vmovups %ymm0, (%rsi)
vmovups 0x30(%rdi), %ymm0
leaq 0x40(%rsp), %rdx
vmovups %ymm0, (%rdx)
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rcx
vzeroupper
callq 0x51b3
vmovups (%r15), %ymm0
leaq 0xa0(%rsp), %rdx
vmovups %ymm0, (%rdx)
vmovups 0x30(%r14), %ymm0
leaq 0x20(%rsp), %rcx
vmovups %ymm0, (%rcx)
movq %rsp, %rdi
movq %r14, %rsi
vzeroupper
callq 0x5154
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5290
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]runningmaxmin/./mono_wedge.h
// Function: std::_Deque_iterator<Sample, Sample&, Sample*> mono_wedge::mono_wedge_search<std::_Deque_iterator<Sample, Sample&, Sample*>, Sample, std::greater<Sample>>(std::_Deque_iterator<Sample, Sample&, Sample*>, std::_Deque_iterator<Sample, Sample&, Sample*>, Sample const&, std::greater<Sample>)
Iterator mono_wedge_search(
		Iterator begin,
		Iterator end,
		const T &value,
		Compare  comp)
	{
		long size = long(end - begin);
		if (size <= 0) return end;

		// Linear search through at most J elements, J = log2(N-J).
		long i = 1;
		for (; ((size-i) >> i) > 0; ++i)
		{
			// If you get a compile error here, your Wedge type does not
			//   support random-access iterators and should be changed!
			Iterator test = end-i;
			if (comp(*test, value)) return test+1;
		}

		// Defer to lower_bound for binary search.
		return std::lower_bound<Iterator, T, Compare>(begin, end-(i-1), value, comp);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
movq %rdx, %rdi
callq 0x54fb
testq %rax, %rax
jle 0x5222
movq %rax, %r13
movq %rbp, (%rsp)
decq %r13
xorl %edx, %edx
leaq 0x8(%rsp), %rbp
leaq 0x1(%rdx), %rbx
movq %r13, %rax
movl %ebx, %ecx
sarq %cl, %rax
testq %rax, %rax
jle 0x522e
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x563c
movq 0x8(%rsp), %rax
vmovsd (%rax), %xmm0
vucomisd (%r14), %xmm0
ja 0x5267
decq %r13
movq %rbx, %rdx
jmp 0x51eb
vmovupd (%r15), %ymm0
vmovupd %ymm0, (%rbp)
jmp 0x527b
vmovups (%r12), %ymm0
leaq 0x48(%rsp), %rbx
vmovups %ymm0, (%rbx)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
vzeroupper
callq 0x563c
movq (%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x5b0e
jmp 0x527b
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
movq (%rsp), %rbp
movq %rbp, %rdi
callq 0x55ae
movq %rbp, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
movq 0x10(%rdi), %rdx
movb 0x18(%rdi), %r8b
pushq $0x1
popq %rax
movq %rcx, %r9
cmpq %rsi, %r9
jae 0x170b
cmpb %r8b, (%rdx,%r9)
je 0x170b
incq %r9
movq %r9, (%rdi)
incq %rax
jmp 0x16e9
cmpb %r8b, (%rdx,%r9)
jne 0x1710
incq %r9
movq %r9, (%rdi)
cmpq %rsi, %r9
jb 0x16ff
addq %rdx, %rcx
testq %rdx, %rdx
leaq 0x9b7(%rip), %rdx       # 0x20d4
cmovneq %rcx, %rdx
decq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
andq $0x0, (%rsi)
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rsp, %r15
cmpq 0x8(%r14), %rax
jae 0x1770
movq %r14, %rdi
callq 0x16d4
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1790
movq (%r14), %rax
jmp 0x1749
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x169e
movq %r14, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %rbx
movl %edi, %r14d
leal -0x1(%r14), %eax
movl %eax, 0x4(%rsp)
leal -0x4(%r14), %eax
movl %eax, (%rsp)
pushq $0x1
popq %rbp
leaq 0x2fa4(%rip), %r15      # 0xb13c
cmpl %r14d, %ebp
jge 0x826c
movslq %ebp, %rax
movq (%rbx,%rax,8), %r13
movb (%r13), %r12b
cmpb $0x2d, %r12b
jne 0x81c4
cmpb $0x68, 0x1(%r13)
jne 0x81c4
cmpb $0x0, 0x2(%r13)
je 0x827b
movq %r13, %rdi
movq %r15, %rsi
callq 0x2260
testl %eax, %eax
je 0x827b
cmpb $0x2d, %r12b
jne 0x81eb
cmpb $0x6c, 0x1(%r13)
jne 0x81eb
cmpb $0x0, 0x2(%r13)
je 0x823d
movq %r13, %rdi
leaq 0x2f4e(%rip), %rsi      # 0xb143
callq 0x2260
testl %eax, %eax
je 0x823d
cmpb $0x2d, %r12b
jne 0x8212
cmpb $0x76, 0x1(%r13)
jne 0x8212
cmpb $0x0, 0x2(%r13)
je 0x8246
movq %r13, %rdi
leaq 0x2f33(%rip), %rsi      # 0xb14f
callq 0x2260
testl %eax, %eax
je 0x8246
cmpl 0x4(%rsp), %ebp
jge 0x824f
movl %ebp, %edi
movq %rbx, %rsi
callq 0x7d1c
testb %al, %al
je 0x824f
incl %ebp
jmp 0x8265
movb $0x1, 0x801c(%rip)      # 0x10260
jmp 0x8265
movb $0x1, 0x8014(%rip)      # 0x10261
jmp 0x8265
cmpl (%rsp), %ebp
jge 0x828a
movl %ebp, %edi
movq %rbx, %rsi
callq 0x7eed
testb %al, %al
je 0x828a
addl $0x4, %ebp
incl %ebp
jmp 0x8198
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
callq 0x7718
xorl %edi, %edi
callq 0x21f0
movq 0x7d47(%rip), %rdi      # 0xffd8
leaq 0x2ec1(%rip), %rsi      # 0xb159
callq 0x2190
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x20d0
movq (%rbx), %rdi
callq 0x7718
pushq $0x1
popq %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x82fb
xorl %eax, %eax
cmpq $0x4, %rax
je 0x82fb
cmpl $0x100, (%rdi,%rax,4)   # imm = 0x100
leaq 0x1(%rax), %rax
jb 0x82c4
pushq %rax
movq 0x7cf9(%rip), %rdi      # 0xffd8
leaq 0x2e85(%rip), %rsi      # 0xb16b
callq 0x2190
movq %rax, %rdi
callq 0x20d0
pushq $0x1
popq %rdi
callq 0x21f0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7fa4(%rip), %rdi      # 0x102a8
callq 0x82bd
movq 0x7fa0(%rip), %rdi      # 0x102b0
callq 0x82bd
movq 0x7f9c(%rip), %rdi      # 0x102b8
callq 0x82bd
movq 0x7f98(%rip), %rdi      # 0x102c0
callq 0x82bd
movq 0x7f94(%rip), %rdi      # 0x102c8
callq 0x82bd
movq 0x7f90(%rip), %rdi      # 0x102d0
callq 0x82bd
movq 0x7f8c(%rip), %rdi      # 0x102d8
callq 0x82bd
movq 0x7f88(%rip), %rdi      # 0x102e0
callq 0x82bd
cmpl $0x100, 0x7f21(%rip)    # imm = 0x100
jae 0x8390
movl 0x7e79(%rip), %eax      # 0x101e8
addl $-0x21, %eax
cmpl $-0x21, %eax
jbe 0x83a0
movq 0x7eea(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x838e
callq 0x20b0
cmpq $0x21, %rax
jae 0x83b0
popq %rax
retq
movq 0x7c41(%rip), %rdi      # 0xffd8
leaq 0x2dfc(%rip), %rsi      # 0xb19a
jmp 0x83be
movq 0x7c31(%rip), %rdi      # 0xffd8
leaq 0x2e1d(%rip), %rsi      # 0xb1cb
jmp 0x83be
movq 0x7c21(%rip), %rdi      # 0xffd8
leaq 0x2e26(%rip), %rsi      # 0xb1e4
callq 0x2190
movq %rax, %rdi
callq 0x20d0
pushq $0x1
popq %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x70ae(%rip)      # 0x10261
jne 0x91e6
movq 0x6e1c(%rip), %rdi      # 0xffd8
leaq 0x2257(%rip), %rsi      # 0xb41a
callq 0x2190
movq 0x7089(%rip), %rsi      # 0x10258
movq %rax, %rdi
callq 0x2190
leaq 0x2258(%rip), %rsi      # 0xb436
movq %rax, %rdi
callq 0x2190
movq 0x706b(%rip), %rsi      # 0x10258
movq %rbx, %rdi
callq 0x4b84
cmpb $0x1, 0x7065(%rip)      # 0x10261
jne 0x9219
movq 0x6dd3(%rip), %rdi      # 0xffd8
leaq 0x2096(%rip), %rsi      # 0xb2a2
callq 0x2190
movq %rax, %rdi
callq 0x20d0
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x92a3
movq %rbx, %rdi
callq 0x2210
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x764a
movq %rbx, %rdi
callq 0x20a0
movq 0x6d8d(%rip), %rdi      # 0xffd8
leaq 0x21e9(%rip), %rsi      # 0xb43b
callq 0x2190
movq 0x6ffa(%rip), %rsi      # 0x10258
movq %rax, %rdi
callq 0x2190
leaq 0x206d(%rip), %rsi      # 0xb2da
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20d0
leaq 0x8(%rsp), %rdi
callq 0x7664
callq 0x22f0
jmp 0x91f5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7664
callq 0x22f0
movq %rbx, %rdi
callq 0x2330
movq %rax, %rdi
callq 0x399a
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6950(%rip), %rdi      # 0xffd8
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rdi,%rax)
pushq $0x30
popq %rsi
callq 0x22c0
leaq 0x1e42(%rip), %rsi      # 0xb4ee
movq %rax, %rdi
callq 0x2190
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
pushq $0x2
popq %r12
movq %r12, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x4d3e
movq %r14, %rdi
movl %eax, %esi
callq 0x2310
leaq 0x1e0c(%rip), %r14      # 0xb4ec
movq %rax, %rdi
movq %r14, %rsi
callq 0x2190
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq %rbx, %rdi
callq 0x4d4e
movq %r15, %rdi
movl %eax, %esi
callq 0x2310
movq %rax, %rdi
movq %r14, %rsi
callq 0x2190
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq %rbx, %rdi
callq 0x4d5e
movq %r15, %rdi
movl %eax, %esi
callq 0x2310
movq %rax, %rdi
movq %r14, %rsi
callq 0x2190
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x4d6e
movq %r14, %rdi
movl %eax, %esi
callq 0x2310
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x67d1(%rip), %xmm2     # 0xc060
jbe 0x58b3
movsd 0x67c7(%rip), %xmm3     # 0xc060
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_O2/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 $0x80, %rsp
movl %edx, %ebp
movq %rsi, %rbx
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
leaq 0x58(%rsp), %r14
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x7fec
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x8058
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x43e0
leaq 0x30(%rsp), %rdi
callq 0x80d6
leaq 0x58(%rsp), %rdi
callq 0x80d6
leaq 0x690a(%rip), %rsi      # 0xc230
leaq 0x10(%rsp), %rdi
callq 0x80ec
testb %al, %al
jne 0x5949
leaq 0x68fa(%rip), %rsi      # 0xc235
leaq 0x10(%rsp), %rdi
callq 0x80ec
testb %al, %al
je 0x5972
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x80f9
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x4160
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6958(%rip), %rsi      # 0xc2d1
leaq 0x10(%rsp), %rdi
callq 0x80ec
testb %al, %al
je 0x5996
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x82ee
jmp 0x5958
leaq 0x689e(%rip), %rsi      # 0xc23b
leaq 0x10(%rsp), %rdi
callq 0x80ec
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x857b
jmp 0x5958
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4160
jmp 0x59e1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x80d6
jmp 0x59d7
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x80d6
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x30, %rsp
movsd 0x667a(%rip), %xmm2     # 0xc070
minsd %xmm0, %xmm2
divsd 0x6676(%rip), %xmm2     # 0xc078
cmpltsd 0x6675(%rip), %xmm0     # 0xc080
movq %rdi, %rbx
movsd 0x6672(%rip), %xmm1     # 0xc088
andpd %xmm0, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd 0x6666(%rip), %xmm1     # 0xc090
ucomisd %xmm0, %xmm1
movapd %xmm0, 0x10(%rsp)
jae 0x5aa4
movsd 0x666a(%rip), %xmm2     # 0xc0a8
addsd %xmm0, %xmm2
movsd %xmm2, 0x28(%rsp)
movsd 0x6660(%rip), %xmm1     # 0xc0b0
movapd %xmm2, %xmm0
callq 0x4500
mulsd 0x6657(%rip), %xmm0     # 0xc0b8
movsd 0x65f7(%rip), %xmm2     # 0xc060
minsd %xmm0, %xmm2
xorpd %xmm1, %xmm1
cmpltsd %xmm1, %xmm0
andnpd %xmm2, %xmm0
movapd %xmm0, (%rsp)
movsd 0x6639(%rip), %xmm1     # 0xc0c0
movsd 0x28(%rsp), %xmm0
callq 0x4500
movaps (%rsp), %xmm3
movapd %xmm0, %xmm4
mulsd 0x6626(%rip), %xmm4     # 0xc0c8
jmp 0x5ac5
callq 0x4270
movapd %xmm0, %xmm4
mulsd 0x65e3(%rip), %xmm4     # 0xc098
addsd 0x65e3(%rip), %xmm4     # 0xc0a0
movsd 0x659b(%rip), %xmm3     # 0xc060
movsd 0x6593(%rip), %xmm5     # 0xc060
movapd 0x10(%rsp), %xmm2
ucomisd 0x65b5(%rip), %xmm2     # 0xc090
movapd %xmm5, %xmm0
jae 0x5b49
xorpd %xmm0, %xmm0
movsd 0x65e3(%rip), %xmm1     # 0xc0d0
ucomisd %xmm2, %xmm1
jae 0x5b49
movsd 0x65dd(%rip), %xmm0     # 0xc0d8
addsd %xmm2, %xmm0
movaps %xmm3, (%rsp)
movapd %xmm4, 0x10(%rsp)
callq 0x4270
movsd 0x654a(%rip), %xmm5     # 0xc060
movapd 0x10(%rsp), %xmm4
movaps (%rsp), %xmm3
mulsd 0x65b8(%rip), %xmm0     # 0xc0e0
addsd 0x65b8(%rip), %xmm0     # 0xc0e8
movsd 0x6528(%rip), %xmm1     # 0xc060
minsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
cmpltsd %xmm2, %xmm0
andnpd %xmm1, %xmm0
minsd %xmm4, %xmm5
xorpd %xmm1, %xmm1
cmpltsd %xmm1, %xmm4
andnpd %xmm5, %xmm4
movsd %xmm3, (%rbx)
movlpd %xmm4, 0x8(%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4230
movss %xmm0, 0x10(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x4290
mulss 0x10(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movss 0x8(%rsp), %xmm0
callq 0x4290
movaps %xmm0, 0x20(%rsp)
movss 0x8(%rsp), %xmm0
callq 0x4230
movss %xmm0, 0x8(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x4230
mulss 0x8(%rsp), %xmm0
movaps 0x10(%rsp), %xmm2
unpcklps 0x20(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
movaps 0x65b8(%rip), %xmm1     # 0xc1a0
movss %xmm0, %xmm1            # xmm1 = xmm0[0],xmm1[1,2,3]
movaps %xmm2, %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x30, %rsp
movq %rdi, %rbx
callq 0x5b71
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
leaq 0x20(%rsp), %rsi
movups %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x87a0
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movaps %xmm2, 0x10(%rsp)
xorps 0x6506(%rip), %xmm0     # 0xc1b0
callq 0x43d0
movaps %xmm0, (%rsp)
movaps 0x10(%rsp), %xmm0
callq 0x4490
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtps2pd %xmm1, %xmm0
mulpd 0x64f1(%rip), %xmm0     # 0xc1c0
cvtpd2ps %xmm0, %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x640e(%rip), %xmm0     # 0xc0f0
addsd 0x640e(%rip), %xmm0     # 0xc0f8
movapd %xmm0, %xmm1
divsd 0x640a(%rip), %xmm1     # 0xc100
movsd %xmm1, (%rsp)
movsd 0x635d(%rip), %xmm1     # 0xc060
callq 0x43a0
movsd 0x63f8(%rip), %xmm1     # 0xc108
movsd (%rsp), %xmm2
mulsd %xmm2, %xmm1
addsd 0x63ef(%rip), %xmm1     # 0xc110
mulsd %xmm2, %xmm1
addsd 0x63eb(%rip), %xmm1     # 0xc118
mulsd %xmm2, %xmm1
addsd 0x63e7(%rip), %xmm1     # 0xc120
mulsd 0x63af(%rip), %xmm0     # 0xc0f0
addsd %xmm1, %xmm0
mulsd 0x63db(%rip), %xmm0     # 0xc128
movsd 0x63db(%rip), %xmm1     # 0xc130
callq 0x43a0
movsd 0x63ce(%rip), %xmm3     # 0xc130
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_O2/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 $0x88, %rsp
movsd %xmm3, (%rsp)
movq %rdi, %rbx
cvtsd2ss %xmm2, %xmm6
cvtsd2ss %xmm0, %xmm5
cvtsd2ss %xmm1, %xmm2
movss 0x5eaf(%rip), %xmm3     # 0xc00c
movss 0x5eab(%rip), %xmm4     # 0xc010
movaps %xmm6, %xmm0
movaps %xmm5, %xmm1
callq 0x8916
movsd (%rsp), %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x6180
jnp 0x61eb
cvtsd2ss %xmm1, %xmm0
xorps 0x6025(%rip), %xmm0     # 0xc1b0
movl $0x3f800000, %eax       # imm = 0x3F800000
leaq 0x8(%rsp), %rdx
movl %eax, (%rdx)
xorps %xmm1, %xmm1
movups %xmm1, 0x4(%rdx)
movl %eax, 0x14(%rdx)
movups %xmm1, 0x18(%rdx)
movss 0x5e67(%rip), %xmm1     # 0xc014
movups %xmm1, 0x28(%rdx)
movss %xmm0, 0x38(%rdx)
movl %eax, 0x3c(%rdx)
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x87e8
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x38(%rsp)
cmpq $0x2, %rdi
jb 0x62c2
cmpb $0x4d, (%rsi)
jne 0x62c2
movq %rdi, %rdx
leaq 0x1(%rsi), %rax
addq %rsi, %rdx
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x90e8
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x8a09
movaps %xmm0, %xmm1
mulss 0x5d57(%rip), %xmm1     # 0xc004
movss 0x5d53(%rip), %xmm0     # 0xc008
callq 0x4480
movss %xmm0, 0xc(%rsp)
jmp 0x62e8
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xb(%rsp), %rdx
callq 0x89f0
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x8a09
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x4160
movss 0xc(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
retq
jmp 0x6302
jmp 0x6311
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4160
jmp 0x6314
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x5f05(%rip), %rcx      # 0xc240
pushq $0x4
popq %rdx
callq 0x8a22
movb $0x1, %bpl
testb %al, %al
jne 0x639b
leaq 0x5ef4(%rip), %rcx      # 0xc245
pushq $0x5
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8a22
testb %al, %al
je 0x6367
xorl %ebp, %ebp
jmp 0x639b
leaq 0x20(%rsp), %rbx
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x89f0
pushq $0xa
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x89d4
testl %eax, %eax
setne %bpl
leaq 0x20(%rsp), %rdi
callq 0x4160
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rdi, (%rbx)
movq %rsi, 0x8(%rbx)
movq 0xbedf(%rip), %r15      # 0x12308
movq 0xbee0(%rip), %r12      # 0x12310
cmpq %r12, %r15
je 0x6463
movq 0x10(%r15), %r14
movq 0x18(%r15), %r13
cmpq %r13, %r14
je 0x645d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0xab1f
cmpq 0x8(%r14), %rax
jne 0x6466
addq $0x30, %r14
jmp 0x643d
addq $0x28, %r15
jmp 0x6430
xorl %r14d, %r14d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movq 0x18(%rsi), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movq %r8, %rdx
movq %r9, %rcx
callq *0x10(%rax)
movq 0x28(%r14), %rcx
movb $0x1, %al
cmpq $-0x1, %rcx
je 0x64bb
movb $0x1, (%rbx,%rcx)
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x6549
movq %rbx, %rdi
callq 0x4120
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rdx
callq 0x89f0
movq 0x28(%rsp), %rbx
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x6(%rsp), %rdx
callq 0x89f0
leaq 0x48(%rsp), %r14
movq (%r14), %rdx
leaq 0x5f3f(%rip), %rdi      # 0xc44e
movq %rbx, %rsi
callq 0x8d83
movq %r14, %rdi
callq 0x4160
leaq 0x28(%rsp), %rdi
callq 0x4160
callq 0x44a0
xorl %eax, %eax
jmp 0x64bb
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4160
jmp 0x6544
movq %rax, %rbx
callq 0x44a0
movq %rbx, %rdi
callq 0x4520
movq %rax, %rdi
callq 0x8db1