LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_19_20.cc
// Function: main
int main(int argc, char const *argv[])
{
	std::vector<std::string> v = {"hello", "c++11", "template"};
	std::list<int> l = {1, 2, 3, 4};

	print1(v, std::cout);
	print2(l, std::cout);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
leaq -0x88(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xd02(%rip), %rsi       # 0x2020
leaq 0xd00(%rip), %rdx       # 0x2025
leaq -0x98(%rbp), %r14
movq %r14, %rdi
callq 0x16fc
leaq -0x78(%rbp), %r15
leaq -0x68(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0xcdf(%rip), %rsi       # 0x2026
leaq 0xcdd(%rip), %rdx       # 0x202b
movq %r15, %rdi
callq 0x16fc
leaq -0x58(%rbp), %r15
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0xcc3(%rip), %rsi       # 0x202c
leaq 0xcc4(%rip), %rdx       # 0x2034
movq %r15, %rdi
callq 0x16fc
leaq -0x38(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xa8(%rbp), %rcx
movl $0x3, %edx
callq 0x14c6
movq $-0x60, %r14
movq -0x10(%rbx), %rdi
cmpq %rdi, %rbx
je 0x13af
movq (%rbx), %rsi
incq %rsi
callq 0x1100
addq $-0x20, %rbx
addq $0x20, %r14
jne 0x139b
movaps 0xc50(%rip), %xmm0      # 0x2010
leaq -0xa8(%rbp), %rsi
movups %xmm0, (%rsi)
leaq -0x98(%rbp), %r14
leaq -0x19(%rbp), %rcx
movl $0x4, %edx
movq %r14, %rdi
callq 0x150e
movq 0x2bef(%rip), %rsi      # 0x3fd8
leaq -0x38(%rbp), %rdi
callq 0x1566
movq 0x2bdf(%rip), %rsi      # 0x3fd8
leaq -0x98(%rbp), %rbx
movq %rbx, %rdi
callq 0x1607
movq -0x98(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1429
movq (%rdi), %r14
movl $0x18, %esi
callq 0x1100
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x1414
leaq -0x38(%rbp), %rdi
callq 0x1680
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x14b4
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x1190
jmp 0x14bd
jmp 0x145e
movq %rax, %rbx
addq $-0x10, %r15
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0x1479
movq (%r15), %rsi
incq %rsi
callq 0x1100
leaq -0x20(%r15), %rax
addq $-0x10, %r15
cmpq %r14, %r15
movq %rax, %r15
jne 0x1465
jmp 0x14bd
movq %rax, %rbx
jmp 0x14bd
movq %rax, %rbx
movq -0x98(%rbp), %rdi
cmpq %r14, %rdi
je 0x14b4
movq (%rdi), %r15
movl $0x18, %esi
callq 0x1100
movq %r15, %rdi
cmpq %r14, %r15
jne 0x149f
leaq -0x38(%rbp), %rdi
callq 0x1680
movq %rbx, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_19_20.cc
// Function: std::ostream& print1<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::ostream&)
std::ostream& print1(const Container& container, std::ostream& os)
{
	for (typename Container::size_type i = 0; i != container.size(); ++i) {
		os << container[i] << " ";
	}
	os << std::endl;

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x15ce
movq %rdi, %r14
movl $0x8, %r12d
xorl %r13d, %r13d
leaq 0xafd(%rip), %r15       # 0x2090
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x1110
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1110
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r12
cmpq %rcx, %r13
jne 0x1593
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_19_20.cc
// Function: std::ostream& print2<std::__cxx11::list<int, std::allocator<int>>>(std::__cxx11::list<int, std::allocator<int>> const&, std::ostream&)
std::ostream& print2(const Container& container, std::ostream& os)
{
	for (auto iter = container.cbegin(); iter != container.cend(); ++iter) {
		os << *iter << " ";
	}
	os << std::endl;

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r12
cmpq %rdi, %r12
je 0x164d
movq %rdi, %r14
leaq 0xa69(%rip), %r15       # 0x2090
movl 0x10(%r12), %esi
movq %rbx, %rdi
callq 0x1150
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1110
movq (%r12), %r12
cmpq %r14, %r12
jne 0x1627
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/joakimkistowski[P]amd-disable-c6/amd-disable-c6.cpp
// Function: retry_execution_main()
int retry_execution_main() {
    if (direct_execution_main(DISABLE)) {
        for (unsigned int i = 0; i < MAX_RETRIES; i++) {
            std::cout << "Disabling C6 state failed; retrying in " << RETRY_SLEEP_DURATION_S 
                << " seconds" << std::endl;
            sleep(RETRY_SLEEP_DURATION_S);
            if (!direct_execution_main(DISABLE)) {
                return 0;
            }
        }
        std::cerr << "Failed disabling C6 state on retry #" << MAX_RETRIES << "; accepting failure" << std::endl;
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rdi
movl $0x0, (%rdi)
callq 0x3ab9
xorl %ecx, %ecx
testl %eax, %eax
je 0x3e48
movl $0x4, %ebx
movq 0x3281(%rip), %r14      # 0x6fd0
leaq 0x1629(%rip), %r15      # 0x537f
leaq 0x164a(%rip), %r12      # 0x53a7
movq %rsp, %r13
movl $0x27, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
movl $0x4, %esi
movq %r14, %rdi
callq 0x2100
movq %rax, %rbp
movl $0x8, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21e0
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbp, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movl $0x4, %edi
callq 0x2130
movl $0x0, (%rsp)
movq %r13, %rdi
callq 0x3ab9
testl %eax, %eax
je 0x3e46
decl %ebx
jne 0x3d60
movq 0x3210(%rip), %rbx      # 0x6ff0
leaq 0x15c9(%rip), %rsi      # 0x53b0
movl $0x24, %edx
movq %rbx, %rdi
callq 0x21e0
movl $0x4, %esi
movq %rbx, %rdi
callq 0x2100
movq %rax, %rbx
leaq 0x15ca(%rip), %rsi      # 0x53d5
movl $0x13, %edx
movq %rax, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movl $0x1, %ecx
jmp 0x3e48
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/joakimkistowski[P]amd-disable-c6/amd-disable-c6.cpp
// Function: main
int main(const int argc, const char *argv[]) {
    if (!has_amd_cpu()) {
        std::cerr << "Failed disabling of C6 state; no AMD CPU found" << std::endl;
        return 1;
    }
    op_mode mode = parse_op_mode(argc, argv);
    if (mode == RETRYDISABLE) {
        return retry_execution_main();
    } else {
        return direct_execution_main(mode);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x38dc
testb %al, %al
je 0x3e84
movl %ebp, %edi
movq %rbx, %rsi
callq 0x3691
movl %eax, 0x4(%rsp)
cmpl $0x1, %eax
jne 0x3ecd
callq 0x3d1e
jmp 0x3ed7
movq 0x3165(%rip), %rbx      # 0x6ff0
leaq 0x1557(%rip), %rsi      # 0x53e9
movl $0x2e, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movl $0x1, %eax
jmp 0x3ed7
leaq 0x4(%rsp), %rdi
callq 0x3ab9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/Image.h
// Function: Image::Image(char*)
Image::Image(char *type)
{
  if(!strcmp(type, "bw")) 
  {
    imgtype = "bw";
    channels = 1;
    cols = 512; //default
    rows = 512; //default
    imgdata = new unsigned char [cols*rows*channels];
  }
  else
  {
    imgtype = "color";
    channels = 3;
    cols = 512; //default
    rows = 512; //default
    imgdata = new unsigned char [cols*rows*channels];
  }
  
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x62, (%rsi)
jne 0x4c01
cmpb $0x77, 0x1(%rsi)
jne 0x4c01
cmpb $0x0, 0x2(%rsi)
je 0x4c30
leaq 0xcac0(%rip), %rax      # 0x116c8
movq %rax, (%rbx)
movl $0x3, 0x10(%rbx)
movabsq $0x20000000200, %rax    # imm = 0x20000000200
movq %rax, 0x8(%rbx)
movl $0xc0000, %edi          # imm = 0xC0000
callq 0x2030
movq %rax, 0x18(%rbx)
popq %rbx
retq
leaq 0xd61c(%rip), %rax      # 0x12253
movq %rax, (%rbx)
movl $0x1, 0x10(%rbx)
movabsq $0x20000000200, %rax    # imm = 0x20000000200
movq %rax, 0x8(%rbx)
movl $0x40000, %edi          # imm = 0x40000
jmp 0x4c25
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/Image.h
// Function: Image::Image(char*, int, int)
Image::Image(char *type, int width, int height)
{
  if(!strcmp(type, "bw")) 
  {
    imgtype = "bw";
    channels = 1;
    cols = width; 
    rows = height;
    imgdata = new unsigned char [cols*rows*channels];
  }
  else
  {
    imgtype = "color";
    channels = 3;
    cols = width; 
    rows = height;
    imgdata = new unsigned char [cols*rows*channels];
  }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x62, (%rsi)
jne 0x4c6b
cmpb $0x77, 0x1(%rsi)
jne 0x4c6b
cmpb $0x0, 0x2(%rsi)
je 0x4c96
leaq 0xca56(%rip), %rax      # 0x116c8
movq %rax, (%rbx)
movl $0x3, 0x10(%rbx)
movl %edx, 0x8(%rbx)
movl %ecx, 0xc(%rbx)
imull %edx, %ecx
leal (%rcx,%rcx,2), %ecx
movslq %ecx, %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
popq %rbx
retq
leaq 0xd5b6(%rip), %rax      # 0x12253
movq %rax, (%rbx)
movl $0x1, 0x10(%rbx)
movl %edx, 0x8(%rbx)
movl %ecx, 0xc(%rbx)
imull %edx, %ecx
jmp 0x4c88
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/Image.h
// Function: Image::read_image(char const*, int, int)
void Image::read_image(const char *filename, int width, int height)
{
  if (!strcmp(imgtype, "color"))
  {
    //cols = width;
    //rows = height;
    FILE *file;
    if (!(file=fopen(filename,"rb"))) 
    {
      std::cout << "Cannot open file: " << filename << std::endl;
      exit(1);
    }

    if (!(fread(imgdata, sizeof(int), cols*rows*channels, file)))
      std::cout << "Error Reading" << std::endl;

    fclose(file);
  }

  else if (!strcmp(imgtype, "bw"))
  {
    // cols = width;
    // rows = height;

    FILE *file;
    if (!(file=fopen(filename,"rb"))) 
    {
      std::cout << "Cannot open file: " << filename << std::endl;
      exit(1);
    }
    if (!(fread(imgdata, sizeof(int), cols*rows*channels, file)))
      std::cout << "Error Reading" << std::endl;
    fclose(file);  
    
  }

  else
  {
    std::cout << "Filetype wasn't right!" << std::endl;
  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
leaq 0xca01(%rip), %rsi      # 0x116c8
movq %r15, %rdi
callq 0x21f0
testl %eax, %eax
je 0x4d2e
cmpb $0x62, (%r15)
jne 0x4ce7
cmpb $0x77, 0x1(%r15)
jne 0x4ce7
cmpb $0x0, 0x2(%r15)
je 0x4d2e
movq 0x112e2(%rip), %rbx     # 0x15fd0
leaq 0xc9fd(%rip), %rsi      # 0x116f2
movl $0x16, %edx
movq %rbx, %rdi
callq 0x21a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
leaq 0xc999(%rip), %rsi      # 0x116ce
movq %rbx, %rdi
callq 0x21b0
testq %rax, %rax
je 0x4dbe
movq %rax, %r15
movq 0x18(%r14), %rdi
movslq 0x8(%r14), %rax
movslq 0xc(%r14), %rcx
imulq %rax, %rcx
movslq 0x10(%r14), %rdx
imulq %rcx, %rdx
movl $0x4, %esi
movq %r15, %rcx
callq 0x2210
testq %rax, %rax
jne 0x4db1
movq 0x1125a(%rip), %rbx     # 0x15fd0
leaq 0xc967(%rip), %rsi      # 0x116e4
movl $0xd, %edx
movq %rbx, %rdi
callq 0x21a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2170
movq 0x1120b(%rip), %rdi     # 0x15fd0
leaq 0xc905(%rip), %rsi      # 0x116d1
callq 0x2160
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movl $0x1, %edi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/Image.h
// Function: Image::write_image(char const*, int, int)
void Image::write_image(const char *filename, int width, int height)
{
  if (!strcmp(imgtype, "color"))
  {
    // cols = width;
    // rows = height;

    FILE *file;
    if (!(file=fopen(filename,"wb"))) 
    {
      std::cout << "Cannot open file: " << filename << std::endl;
      exit(1);
    }
    if (!(fwrite(imgdata, sizeof(unsigned char), cols*rows*channels, file)))
       std::cout << "Error Writing" << std::endl;
    fclose(file);
   
  }

  else if (!strcmp(imgtype, "bw"))
  {
    // cols = width;
    // rows = height;

    FILE *file;

    if (!(file=fopen(filename,"wb"))) 
    {
      std::cout << "Cannot open file: " << filename << std::endl;
      exit(1);
    }
    if (!(fwrite(imgdata, sizeof(unsigned char), cols*rows*channels, file)))
      std::cout << "Error Writing" << std::endl;
    fclose(file);  

  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
leaq 0xc8c5(%rip), %rsi      # 0x116c8
movq %rbx, %rdi
callq 0x21f0
testl %eax, %eax
je 0x4e26
cmpb $0x62, (%rbx)
jne 0x4e20
cmpb $0x77, 0x1(%rbx)
jne 0x4e20
cmpb $0x0, 0x2(%rbx)
je 0x4e26
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc8dc(%rip), %rsi      # 0x11709
movq %r14, %rdi
callq 0x21b0
testq %rax, %rax
je 0x4eb6
movq %rax, %rbx
movq 0x18(%r15), %rdi
movslq 0x8(%r15), %rax
movslq 0xc(%r15), %rcx
imulq %rax, %rcx
movslq 0x10(%r15), %rdx
imulq %rcx, %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x22f0
testq %rax, %rax
jne 0x4ea9
movq 0x11162(%rip), %r14     # 0x15fd0
leaq 0xc897(%rip), %rsi      # 0x1170c
movl $0xd, %edx
movq %r14, %rdi
callq 0x21a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2170
movq 0x11113(%rip), %rdi     # 0x15fd0
leaq 0xc80d(%rip), %rsi      # 0x116d1
callq 0x2160
movq %rax, %rdi
movq %r14, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movl $0x1, %edi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/Image.h
// Function: Image::operator=(Image)
void Image::operator=(Image img_copy)
{
  strcpy(imgtype, img_copy.imgtype);
  img_copy.rows = rows;
  img_copy.cols = cols;
  img_copy.channels = channels;
  for(int i = 0; i < rows; i++)
    for(int j = 0; j < cols; j++)
      for(int k = 0; k < channels; k++)
        img_copy.setvalue(i,j,k,getvalue(i,j,k));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x2130
movl 0xc(%r14), %esi
movl %esi, 0xc(%rbx)
movl 0x8(%r14), %edx
movl %edx, 0x8(%rbx)
movl 0x10(%r14), %ecx
movl %ecx, 0x10(%rbx)
testl %esi, %esi
jle 0x5005
xorl %eax, %eax
testl %edx, %edx
jle 0x4fff
xorl %esi, %esi
testl %ecx, %ecx
jle 0x4ff5
xorl %edx, %edx
movl 0x8(%r14), %edi
imull %eax, %edi
addl %esi, %edi
imull %ecx, %edi
movslq %edi, %rcx
addq 0x18(%r14), %rcx
movl 0x8(%rbx), %edi
imull %eax, %edi
addl %esi, %edi
imull 0x10(%rbx), %edi
movb (%rdx,%rcx), %cl
movslq %edi, %rdi
addq 0x18(%rbx), %rdi
movb %cl, (%rdx,%rdi)
movl 0x10(%r14), %ecx
incq %rdx
cmpl %ecx, %edx
jl 0x4fba
movl 0x8(%r14), %edx
incl %esi
cmpl %edx, %esi
jl 0x4fb4
movl 0xc(%r14), %esi
incl %eax
cmpl %esi, %eax
jl 0x4fae
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Ycbcr2Rgb(double*, double*, double*, double, double, double)
void Ycbcr2Rgb(num *R, num *G, num *B, num Y, num Cr, num Cb)
{
	Y -= 16;
	Cb -= 128;
	Cr -= 128;
	*R = (num)(0.00456621004566210107*Y + 1.1808799897946415e-09*Cr + 0.00625892896994393634*Cb);
	*G = (num)(0.00456621004566210107*Y - 0.00153632368604490212*Cr - 0.00318811094965570701*Cb);
	*B = (num)(0.00456621004566210107*Y + 0.00791071623355474145*Cr + 1.1977497040190077e-08*Cb);
}

// Assembly:
addsd 0xbf34(%rip), %xmm0     # 0x110d0
movsd 0xbf34(%rip), %xmm3     # 0x110d8
addsd %xmm3, %xmm2
addsd %xmm3, %xmm1
movsd 0xbf2c(%rip), %xmm3     # 0x110e0
mulsd 0xbf2c(%rip), %xmm0     # 0x110e8
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movsd 0xbf24(%rip), %xmm4     # 0x110f0
mulsd %xmm2, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rdi)
movsd 0xbf18(%rip), %xmm3     # 0x110f8
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movsd 0xbf10(%rip), %xmm4     # 0x11100
mulsd %xmm2, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rsi)
mulsd 0xbf04(%rip), %xmm1     # 0x11108
addsd %xmm0, %xmm1
mulsd 0xbf00(%rip), %xmm2     # 0x11110
addsd %xmm1, %xmm2
movsd %xmm2, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Rgb2Hsv(double*, double*, double*, double, double, double)
void Rgb2Hsv(num *H, num *S, num *V, num R, num G, num B)
{
	num Max = MAX3(R, G, B);
	num Min = MIN3(R, G, B);
	num C = Max - Min;
	
	
	*V = Max;
	
	if(C > 0)
	{
		if(Max == R)
		{
			*H = (G - B) / C;
			
			if(G < B)
				*H += 6;
		}
		else if(Max == G)
			*H = 2 + (B - R) / C;
		else
			*H = 4 + (R - G) / C;
		
		*H *= 60;
		*S = C / Max;
	}
	else
		*H = *S = 0;
}

// Assembly:
movapd %xmm1, %xmm4
cmplesd %xmm0, %xmm4
movapd %xmm4, %xmm3
andpd %xmm0, %xmm3
andnpd %xmm1, %xmm4
orpd %xmm3, %xmm4
movapd %xmm2, %xmm3
cmplesd %xmm4, %xmm3
movapd %xmm3, %xmm5
andpd %xmm4, %xmm5
andnpd %xmm2, %xmm3
orpd %xmm5, %xmm3
movapd %xmm0, %xmm4
cmplesd %xmm1, %xmm4
movapd %xmm4, %xmm5
andpd %xmm0, %xmm5
andnpd %xmm1, %xmm4
orpd %xmm5, %xmm4
movapd %xmm4, %xmm5
cmplesd %xmm2, %xmm5
movapd %xmm5, %xmm6
andpd %xmm4, %xmm6
andnpd %xmm2, %xmm5
orpd %xmm6, %xmm5
movapd %xmm3, %xmm4
subsd %xmm5, %xmm4
movlpd %xmm3, (%rdx)
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm4
jbe 0x56c3
ucomisd %xmm0, %xmm3
jne 0x56cc
jp 0x56cc
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
divsd %xmm4, %xmm0
ucomisd %xmm1, %xmm2
jbe 0x56fa
addsd 0xbb9f(%rip), %xmm0     # 0x11260
jmp 0x56fa
xorl %eax, %eax
movq %rax, (%rsi)
movq %rax, (%rdi)
retq
ucomisd %xmm1, %xmm3
jne 0x56ea
jp 0x56ea
subsd %xmm0, %xmm2
divsd %xmm4, %xmm2
addsd 0xbb74(%rip), %xmm2     # 0x11258
movapd %xmm2, %xmm0
jmp 0x56fa
subsd %xmm1, %xmm0
divsd %xmm4, %xmm0
addsd 0xbb56(%rip), %xmm0     # 0x11250
mulsd 0xbb66(%rip), %xmm0     # 0x11268
movsd %xmm0, (%rdi)
divsd %xmm3, %xmm4
movsd %xmm4, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Hsv2Rgb(double*, double*, double*, double, double, double)
void Hsv2Rgb(num *R, num *G, num *B, num H, num S, num V)
{
	num C = S * V;
	num Min = V - C;
	num X;
	
	
	H -= 360*floor(H/360);
	H /= 60;
	X = C*(1 - fabs(H - 2*floor(H/2) - 1));
	
	switch((int)H)
	{
	case 0:
		*R = Min + C;
		*G = Min + X;
		*B = Min;
		break;
	case 1:
		*R = Min + X;
		*G = Min + C;
		*B = Min;
		break;
	case 2:
		*R = Min;
		*G = Min + C;
		*B = Min + X;
		break;
	case 3:
		*R = Min;
		*G = Min + X;
		*B = Min + C;
		break;
	case 4:
		*R = Min + X;
		*G = Min;
		*B = Min + C;
		break;
	case 5:
		*R = Min + C;
		*G = Min;
		*B = Min + X;
		break;
	default:
		*R = *G = *B = 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
divsd 0xbb36(%rip), %xmm0     # 0x11270
callq 0x2270
movapd %xmm0, %xmm1
mulsd 0xbb2d(%rip), %xmm1     # 0x11278
addsd (%rsp), %xmm1
divsd 0xbb10(%rip), %xmm1     # 0x11268
movapd %xmm1, (%rsp)
movsd 0xb9c3(%rip), %xmm0     # 0x11128
mulsd %xmm1, %xmm0
callq 0x2270
movapd (%rsp), %xmm3
cvttsd2si %xmm3, %eax
cmpl $0x5, %eax
ja 0x5848
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm1
addsd %xmm0, %xmm0
subsd %xmm0, %xmm3
addsd 0xbadc(%rip), %xmm3     # 0x11280
andpd 0xbd44(%rip), %xmm3     # 0x114f0
movsd 0xbad4(%rip), %xmm0     # 0x11288
subsd %xmm3, %xmm0
mulsd %xmm2, %xmm0
leaq 0xbe9d(%rip), %rcx      # 0x11660
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm1, %xmm2
movsd %xmm2, (%r15)
addsd %xmm1, %xmm0
movsd %xmm0, (%r14)
jmp 0x582a
addsd %xmm1, %xmm0
movsd %xmm0, (%r15)
movsd %xmm1, (%r14)
jmp 0x580e
movsd %xmm1, (%r15)
addsd %xmm1, %xmm2
movsd %xmm2, (%r14)
jmp 0x583e
movsd %xmm1, (%r15)
addsd %xmm1, %xmm0
movsd %xmm0, (%r14)
addsd %xmm1, %xmm2
movsd %xmm2, (%rbx)
jmp 0x5853
addsd %xmm1, %xmm0
movsd %xmm0, (%r15)
addsd %xmm1, %xmm2
movsd %xmm2, (%r14)
movsd %xmm1, (%rbx)
jmp 0x5853
addsd %xmm1, %xmm2
movsd %xmm2, (%r15)
movsd %xmm1, (%r14)
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
jmp 0x5853
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, (%r14)
movq %rax, (%r15)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Rgb2Hsl(double*, double*, double*, double, double, double)
void Rgb2Hsl(num *H, num *S, num *L, num R, num G, num B)
{
	num Max = MAX3(R, G, B);
	num Min = MIN3(R, G, B);
	num C = Max - Min;
	
	
	*L = (Max + Min)/2;
	
	if(C > 0)
	{
		if(Max == R)
		{
			*H = (G - B) / C;
			
			if(G < B)
				*H += 6;
		}
		else if(Max == G)
			*H = 2 + (B - R) / C;
		else
			*H = 4 + (R - G) / C;
		
		*H *= 60;
		*S = (*L <= 0.5) ? (C/(2*(*L))) : (C/(2 - 2*(*L)));
	}
	else
		*H = *S = 0;
}

// Assembly:
movapd %xmm1, %xmm3
cmplesd %xmm0, %xmm3
movapd %xmm3, %xmm4
andpd %xmm0, %xmm4
andnpd %xmm1, %xmm3
orpd %xmm4, %xmm3
movapd %xmm2, %xmm4
cmplesd %xmm3, %xmm4
movapd %xmm4, %xmm5
andpd %xmm3, %xmm5
andnpd %xmm2, %xmm4
orpd %xmm5, %xmm4
movapd %xmm0, %xmm3
cmplesd %xmm1, %xmm3
movapd %xmm3, %xmm5
andpd %xmm0, %xmm5
andnpd %xmm1, %xmm3
orpd %xmm5, %xmm3
movapd %xmm3, %xmm5
cmplesd %xmm2, %xmm5
movapd %xmm5, %xmm6
andpd %xmm3, %xmm6
andnpd %xmm2, %xmm5
orpd %xmm6, %xmm5
movapd %xmm4, %xmm3
subsd %xmm5, %xmm3
addsd %xmm4, %xmm5
mulsd 0xb853(%rip), %xmm5     # 0x11128
movsd %xmm5, (%rdx)
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm3
jbe 0x5907
ucomisd %xmm0, %xmm4
jne 0x5910
jp 0x5910
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
divsd %xmm3, %xmm0
ucomisd %xmm1, %xmm2
jbe 0x593e
addsd 0xb95b(%rip), %xmm0     # 0x11260
jmp 0x593e
xorl %eax, %eax
movq %rax, (%rsi)
movq %rax, (%rdi)
retq
ucomisd %xmm1, %xmm4
jne 0x592e
jp 0x592e
subsd %xmm0, %xmm2
divsd %xmm3, %xmm2
addsd 0xb930(%rip), %xmm2     # 0x11258
movapd %xmm2, %xmm0
jmp 0x593e
subsd %xmm1, %xmm0
divsd %xmm3, %xmm0
addsd 0xb912(%rip), %xmm0     # 0x11250
mulsd 0xb922(%rip), %xmm0     # 0x11268
movsd %xmm0, (%rdi)
movsd (%rdx), %xmm0
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
movsd 0xb8fa(%rip), %xmm2     # 0x11258
subsd %xmm1, %xmm2
cmpnlesd 0xb7bd(%rip), %xmm0     # 0x11128
movapd %xmm0, %xmm4
andnpd %xmm1, %xmm4
andpd %xmm2, %xmm0
orpd %xmm4, %xmm0
divsd %xmm0, %xmm3
movsd %xmm3, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Hsl2Rgb(double*, double*, double*, double, double, double)
void Hsl2Rgb(num *R, num *G, num *B, num H, num S, num L)
{
	num C = (L <= 0.5) ? (2*L*S) : ((2 - 2*L)*S);
	num Min = L - 0.5*C;
	num X;
	
	
	H -= 360*floor(H/360);
	H /= 60;
	X = C*(1 - fabs(H - 2*floor(H/2) - 1));
	
	switch((int)H)
	{
	case 0:
		*R = Min + C;
		*G = Min + X;
		*B = Min;
		break;
	case 1:
		*R = Min + X;
		*G = Min + C;
		*B = Min;
		break;
	case 2:
		*R = Min;
		*G = Min + C;
		*B = Min + X;
		break;
	case 3:
		*R = Min;
		*G = Min + X;
		*B = Min + C;
		break;
	case 4:
		*R = Min + X;
		*G = Min;
		*B = Min + C;
		break;
	case 5:
		*R = Min + C;
		*G = Min;
		*B = Min + X;
		break;
	default:
		*R = *G = *B = 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
divsd 0xb8c1(%rip), %xmm0     # 0x11270
callq 0x2270
mulsd 0xb8bc(%rip), %xmm0     # 0x11278
addsd (%rsp), %xmm0
divsd 0xb89f(%rip), %xmm0     # 0x11268
movapd %xmm0, (%rsp)
mulsd 0xb752(%rip), %xmm0     # 0x11128
callq 0x2270
movapd (%rsp), %xmm5
cvttsd2si %xmm5, %eax
cmpl $0x5, %eax
ja 0x5aea
movsd 0x18(%rsp), %xmm4
movapd %xmm4, %xmm2
addsd %xmm4, %xmm2
movsd 0xb855(%rip), %xmm3     # 0x11258
subsd %xmm2, %xmm3
movapd %xmm4, %xmm1
cmpnlesd 0xb714(%rip), %xmm1     # 0x11128
andpd %xmm1, %xmm3
andnpd %xmm2, %xmm1
orpd %xmm3, %xmm1
mulsd 0x10(%rsp), %xmm1
movsd 0xb712(%rip), %xmm2     # 0x11140
mulsd %xmm1, %xmm2
addsd %xmm4, %xmm2
addsd %xmm0, %xmm0
subsd %xmm0, %xmm5
addsd 0xb83a(%rip), %xmm5     # 0x11280
andpd 0xbaa2(%rip), %xmm5     # 0x114f0
movsd 0xb832(%rip), %xmm0     # 0x11288
subsd %xmm5, %xmm0
mulsd %xmm1, %xmm0
leaq 0xbc13(%rip), %rcx      # 0x11678
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm2, %xmm1
movsd %xmm1, (%r15)
addsd %xmm2, %xmm0
movsd %xmm0, (%r14)
jmp 0x5acc
addsd %xmm2, %xmm0
movsd %xmm0, (%r15)
movsd %xmm2, (%r14)
jmp 0x5ab0
movsd %xmm2, (%r15)
addsd %xmm2, %xmm1
movsd %xmm1, (%r14)
jmp 0x5ae0
movsd %xmm2, (%r15)
addsd %xmm2, %xmm0
movsd %xmm0, (%r14)
addsd %xmm2, %xmm1
movsd %xmm1, (%rbx)
jmp 0x5af5
addsd %xmm2, %xmm0
movsd %xmm0, (%r15)
addsd %xmm2, %xmm1
movsd %xmm1, (%r14)
movsd %xmm2, (%rbx)
jmp 0x5af5
addsd %xmm2, %xmm1
movsd %xmm1, (%r15)
movsd %xmm2, (%r14)
addsd %xmm2, %xmm0
movsd %xmm0, (%rbx)
jmp 0x5af5
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, (%r14)
movq %rax, (%r15)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Rgb2Hsi(double*, double*, double*, double, double, double)
void Rgb2Hsi(num *H, num *S, num *I, num R, num G, num B)
{
	num alpha = 0.5*(2*R - G - B);
	num beta = 0.866025403784439*(G - B);
	
	
	*I = (R + G + B)/3;
	
	if(*I > 0)
	{
		*S = 1 - MIN3(R,G,B) / *I;
		*H = atan2(beta, alpha)*(180/M_PI);
		
		if(*H < 0)
			*H += 360;
	}
	else
		*H = *S = 0;
}

// Assembly:
pushq %rbx
movapd %xmm0, %xmm3
movq %rdi, %rbx
movapd %xmm0, %xmm5
addsd %xmm1, %xmm5
addsd %xmm2, %xmm5
divsd 0xb775(%rip), %xmm5     # 0x11290
movsd %xmm5, (%rdx)
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
jbe 0x5bc0
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
mulsd 0xb75b(%rip), %xmm0     # 0x11298
movapd %xmm3, %xmm4
addsd %xmm3, %xmm4
subsd %xmm1, %xmm4
subsd %xmm2, %xmm4
mulsd 0xb5d3(%rip), %xmm4     # 0x11128
movapd %xmm3, %xmm6
cmplesd %xmm1, %xmm6
andpd %xmm6, %xmm3
andnpd %xmm1, %xmm6
orpd %xmm3, %xmm6
movapd %xmm6, %xmm1
cmplesd %xmm2, %xmm1
movapd %xmm1, %xmm3
andpd %xmm6, %xmm3
andnpd %xmm2, %xmm1
orpd %xmm3, %xmm1
divsd %xmm5, %xmm1
movsd 0xb6f9(%rip), %xmm2     # 0x11288
subsd %xmm1, %xmm2
movsd %xmm2, (%rsi)
movapd %xmm4, %xmm1
callq 0x2060
mulsd 0xb6f8(%rip), %xmm0     # 0x112a0
movsd %xmm0, (%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5bcb
addsd 0xb6b2(%rip), %xmm0     # 0x11270
jmp 0x5bc7
movq $0x0, (%rsi)
movsd %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Hsi2Rgb(double*, double*, double*, double, double, double)
void Hsi2Rgb(num *R, num *G, num *B, num H, num S, num I)
{
	H -= 360*floor(H/360);
	
	if(H < 120)
	{
		*B = I*(1 - S);
		*R = I*(1 + S*cos(H*(M_PI/180))/cos((60 - H)*(M_PI/180)));
		*G = 3*I - *R - *B;
	}
	else if(H < 240)
	{
		H -= 120;
		*R = I*(1 - S);
		*G = I*(1 + S*cos(H*(M_PI/180))/cos((60 - H)*(M_PI/180)));
		*B = 3*I - *R - *G;
	}
	else
	{
		H -= 240;
		*G = I*(1 - S);
		*B = I*(1 + S*cos(H*(M_PI/180))/cos((60 - H)*(M_PI/180)));
		*R = 3*I - *G - *B;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
divsd 0xb677(%rip), %xmm0     # 0x11270
callq 0x2270
movapd %xmm0, %xmm1
mulsd 0xb66e(%rip), %xmm1     # 0x11278
addsd 0x10(%rsp), %xmm1
movsd 0xb690(%rip), %xmm0     # 0x112a8
ucomisd %xmm1, %xmm0
jbe 0x5cb3
movsd 0xb65e(%rip), %xmm0     # 0x11288
subsd 0x8(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rbx)
movapd %xmm1, %xmm0
mulsd 0xb67a(%rip), %xmm0     # 0x112c0
movsd %xmm1, 0x10(%rsp)
callq 0x22d0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xb603(%rip), %xmm0     # 0x11268
subsd 0x10(%rsp), %xmm0
mulsd 0xb64d(%rip), %xmm0     # 0x112c0
callq 0x22d0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0xb5fe(%rip), %xmm1     # 0x11288
movsd 0x18(%rsp), %xmm0
mulsd %xmm0, %xmm1
movsd %xmm1, (%r15)
mulsd 0xb5ef(%rip), %xmm0     # 0x11290
subsd %xmm1, %xmm0
subsd (%rbx), %xmm0
movsd %xmm0, (%r14)
jmp 0x5de0
movsd 0xb5f5(%rip), %xmm0     # 0x112b0
ucomisd %xmm1, %xmm0
movsd 0xb5c1(%rip), %xmm0     # 0x11288
subsd 0x8(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
jbe 0x5d5f
addsd 0xb5e7(%rip), %xmm1     # 0x112c8
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%r15)
mulsd 0xb5cc(%rip), %xmm1     # 0x112c0
movapd %xmm1, %xmm0
callq 0x22d0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xb557(%rip), %xmm0     # 0x11268
subsd 0x10(%rsp), %xmm0
mulsd 0xb5a1(%rip), %xmm0     # 0x112c0
callq 0x22d0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0xb552(%rip), %xmm1     # 0x11288
movsd 0x18(%rsp), %xmm0
mulsd %xmm0, %xmm1
movsd %xmm1, (%r14)
mulsd 0xb543(%rip), %xmm0     # 0x11290
subsd (%r15), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
jmp 0x5de0
addsd 0xb551(%rip), %xmm1     # 0x112b8
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%r14)
mulsd 0xb546(%rip), %xmm1     # 0x112c0
movapd %xmm1, %xmm0
callq 0x22d0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xb4d1(%rip), %xmm0     # 0x11268
subsd 0x10(%rsp), %xmm0
mulsd 0xb51b(%rip), %xmm0     # 0x112c0
callq 0x22d0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0xb4cc(%rip), %xmm1     # 0x11288
movsd 0x18(%rsp), %xmm0
mulsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
mulsd 0xb4be(%rip), %xmm0     # 0x11290
subsd (%r14), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%r15)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Rgb2Xyz(double*, double*, double*, double, double, double)
void Rgb2Xyz(num *X, num *Y, num *Z, num R, num G, num B)
{
	R = INVGAMMACORRECTION(R);
	G = INVGAMMACORRECTION(G);
	B = INVGAMMACORRECTION(B);
	*X = (num)(0.4123955889674142161*R + 0.3575834307637148171*G + 0.1804926473817015735*B);
	*Y = (num)(0.2125862307855955516*R + 0.7151703037034108499*G + 0.07220049864333622685*B);
	*Z = (num)(0.01929721549174694484*R + 0.1191838645808485318*G + 0.9504971251315797660*B);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movapd %xmm1, %xmm4
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0xb4c8(%rip), %xmm1     # 0x112d0
ucomisd %xmm0, %xmm1
movsd %xmm2, 0x10(%rsp)
jae 0x5e47
addsd 0xb4c4(%rip), %xmm0     # 0x112e0
divsd 0xb4c4(%rip), %xmm0     # 0x112e8
movsd 0xb4c4(%rip), %xmm1     # 0x112f0
movsd %xmm4, 0x8(%rsp)
callq 0x2290
movsd 0xb491(%rip), %xmm1     # 0x112d0
movsd 0x8(%rsp), %xmm4
jmp 0x5e4f
divsd 0xb489(%rip), %xmm0     # 0x112d8
movsd %xmm0, 0x18(%rsp)
ucomisd %xmm4, %xmm1
jae 0x5e8a
addsd 0xb47d(%rip), %xmm4     # 0x112e0
divsd 0xb47d(%rip), %xmm4     # 0x112e8
movsd 0xb47d(%rip), %xmm1     # 0x112f0
movapd %xmm4, %xmm0
callq 0x2290
movsd 0xb44c(%rip), %xmm1     # 0x112d0
movapd %xmm0, %xmm4
jmp 0x5e92
divsd 0xb446(%rip), %xmm4     # 0x112d8
movsd 0x10(%rsp), %xmm0
ucomisd %xmm0, %xmm1
jae 0x5ec9
addsd 0xb43a(%rip), %xmm0     # 0x112e0
divsd 0xb43a(%rip), %xmm0     # 0x112e8
movsd 0xb43a(%rip), %xmm1     # 0x112f0
movsd %xmm4, 0x8(%rsp)
callq 0x2290
movsd 0x8(%rsp), %xmm4
jmp 0x5ed1
divsd 0xb407(%rip), %xmm0     # 0x112d8
movsd 0xb41f(%rip), %xmm2     # 0x112f8
mulsd %xmm4, %xmm2
movsd 0xb41b(%rip), %xmm1     # 0x11300
movsd 0x18(%rsp), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd 0xb40d(%rip), %xmm2     # 0x11308
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%r15)
movsd 0xb400(%rip), %xmm2     # 0x11310
mulsd %xmm4, %xmm2
movsd 0xb3fc(%rip), %xmm1     # 0x11318
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd 0xb3f4(%rip), %xmm2     # 0x11320
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
mulsd 0xb3ec(%rip), %xmm4     # 0x11328
movsd %xmm2, (%r14)
mulsd 0xb3e7(%rip), %xmm3     # 0x11330
addsd %xmm4, %xmm3
mulsd 0xb3e3(%rip), %xmm0     # 0x11338
addsd %xmm3, %xmm0
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Xyz2Rgb(double*, double*, double*, double, double, double)
void Xyz2Rgb(num *R, num *G, num *B, num X, num Y, num Z)
{	
	num R1, B1, G1, Min;
	
	
	R1 = (num)( 3.2406*X - 1.5372*Y - 0.4986*Z);
	G1 = (num)(-0.9689*X + 1.8758*Y + 0.0415*Z);
	B1 = (num)( 0.0557*X - 0.2040*Y + 1.0570*Z);
	
	Min = MIN3(R1, G1, B1);
	
	/* Force nonnegative values so that gamma correction is well-defined. */
	if(Min < 0)
	{
		R1 -= Min;
		G1 -= Min;
		B1 -= Min;
	}

	/* Transform from RGB to R'G'B' */
	*R = GAMMACORRECTION(R1);
	*G = GAMMACORRECTION(G1);
	*B = GAMMACORRECTION(B1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movapd %xmm0, %xmm3
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movapd %xmm1, %xmm0
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
mulpd 0xb573(%rip), %xmm0     # 0x11500
movapd %xmm3, %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
mulpd 0xb573(%rip), %xmm4     # 0x11510
addpd %xmm0, %xmm4
movapd %xmm2, %xmm0
unpcklpd %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
mulpd 0xb56f(%rip), %xmm0     # 0x11520
mulsd 0xb387(%rip), %xmm1     # 0x11340
mulsd 0xb387(%rip), %xmm3     # 0x11348
addpd %xmm4, %xmm0
addsd %xmm1, %xmm3
mulsd 0xb37f(%rip), %xmm2     # 0x11350
addsd %xmm3, %xmm2
movapd %xmm0, %xmm6
unpckhpd %xmm0, %xmm6            # xmm6 = xmm6[1],xmm0[1]
movapd %xmm0, %xmm1
cmplesd %xmm6, %xmm1
movapd %xmm1, %xmm3
andpd %xmm0, %xmm3
andnpd %xmm6, %xmm1
orpd %xmm3, %xmm1
movapd %xmm1, %xmm3
cmplesd %xmm2, %xmm3
movapd %xmm3, %xmm4
andpd %xmm1, %xmm4
andnpd %xmm2, %xmm3
orpd %xmm4, %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm3, %xmm4
movapd %xmm2, %xmm1
subsd %xmm3, %xmm1
movapd %xmm3, %xmm5
cmpltsd %xmm4, %xmm5
andpd %xmm5, %xmm1
andnpd %xmm2, %xmm5
jbe 0x603a
subsd %xmm3, %xmm0
subsd %xmm3, %xmm6
orpd %xmm1, %xmm5
movsd 0xb312(%rip), %xmm1     # 0x11358
ucomisd %xmm0, %xmm1
movapd %xmm5, (%rsp)
jae 0x6084
movsd 0xb307(%rip), %xmm1     # 0x11360
movapd %xmm6, 0x10(%rsp)
callq 0x2290
movsd 0xb2ec(%rip), %xmm1     # 0x11358
movapd 0x10(%rsp), %xmm6
mulsd 0xb26e(%rip), %xmm0     # 0x112e8
addsd 0xb2e6(%rip), %xmm0     # 0x11368
jmp 0x608c
mulsd 0xb24c(%rip), %xmm0     # 0x112d8
movsd %xmm0, (%r15)
ucomisd %xmm6, %xmm1
jae 0x60c6
movsd 0xb2c1(%rip), %xmm1     # 0x11360
movapd %xmm6, %xmm0
callq 0x2290
movsd 0xb2a8(%rip), %xmm1     # 0x11358
movapd %xmm0, %xmm6
mulsd 0xb22c(%rip), %xmm6     # 0x112e8
addsd 0xb2a4(%rip), %xmm6     # 0x11368
jmp 0x60ce
mulsd 0xb20a(%rip), %xmm6     # 0x112d8
movapd (%rsp), %xmm0
movsd %xmm6, (%r14)
ucomisd %xmm0, %xmm1
jae 0x60fd
movsd 0xb27a(%rip), %xmm1     # 0x11360
callq 0x2290
mulsd 0xb1f5(%rip), %xmm0     # 0x112e8
addsd 0xb26d(%rip), %xmm0     # 0x11368
jmp 0x6105
mulsd 0xb1d3(%rip), %xmm0     # 0x112d8
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Xyz2Lab(double*, double*, double*, double, double, double)
void Xyz2Lab(num *L, num *a, num *b, num X, num Y, num Z)
{
	X /= WHITEPOINT_X;
	Y /= WHITEPOINT_Y;
	Z /= WHITEPOINT_Z;
	X = LABF(X);
	Y = LABF(Y);
	Z = LABF(Z);
	*L = 116*Y - 16;
	*a = 500*(X - Y);
	*b = 200*(Y - Z);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movapd %xmm2, %xmm3
movapd %xmm1, %xmm2
movq %rdx, %rbx
movq %rsi, %r14
divsd 0xb23e(%rip), %xmm0     # 0x11370
movq %rdi, %r15
ucomisd 0xb243(%rip), %xmm0     # 0x11380
jae 0x6151
mulsd 0xb249(%rip), %xmm0     # 0x11390
addsd 0xb249(%rip), %xmm0     # 0x11398
jmp 0x6176
movsd 0xb22f(%rip), %xmm1     # 0x11388
movsd %xmm2, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
callq 0x2290
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
divsd 0xb1fa(%rip), %xmm3     # 0x11378
ucomisd 0xb1fa(%rip), %xmm2     # 0x11380
movsd %xmm0, 0x18(%rsp)
jae 0x61a0
mulsd 0xb1fa(%rip), %xmm2     # 0x11390
addsd 0xb1fa(%rip), %xmm2     # 0x11398
jmp 0x61c1
movsd 0xb1e0(%rip), %xmm1     # 0x11388
movapd %xmm2, %xmm0
movsd %xmm3, 0x8(%rsp)
callq 0x2290
movsd 0x8(%rsp), %xmm3
movapd %xmm0, %xmm2
ucomisd 0xb1b7(%rip), %xmm3     # 0x11380
jae 0x61dd
mulsd 0xb1bd(%rip), %xmm3     # 0x11390
addsd 0xb1bd(%rip), %xmm3     # 0x11398
jmp 0x61fe
movsd 0xb1a3(%rip), %xmm1     # 0x11388
movapd %xmm3, %xmm0
movsd %xmm2, 0x10(%rsp)
callq 0x2290
movsd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm3
movsd 0xb19a(%rip), %xmm0     # 0x113a0
mulsd %xmm2, %xmm0
addsd 0xaebe(%rip), %xmm0     # 0x110d0
movsd %xmm0, (%r15)
movsd 0x18(%rsp), %xmm0
subsd %xmm2, %xmm0
mulsd 0xb17f(%rip), %xmm0     # 0x113a8
movsd %xmm0, (%r14)
subsd %xmm3, %xmm2
mulsd 0xb176(%rip), %xmm2     # 0x113b0
movsd %xmm2, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Lab2Rgb(double*, double*, double*, double, double, double)
void Lab2Xyz(num *X, num *Y, num *Z, num L, num a, num b)
{
	L = (L + 16)/116;
	a = L + a/500;
	b = L - b/200;
	*X = WHITEPOINT_X*LABINVF(a);
	*Y = WHITEPOINT_Y*LABINVF(L);
	*Z = WHITEPOINT_Z*LABINVF(b);
}

// Assembly:
addsd 0xa82b(%rip), %xmm0     # 0x11098
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
divpd 0xacb7(%rip), %xmm0     # 0x11530
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd 0xab2b(%rip), %xmm2     # 0x113b8
movapd %xmm1, %xmm7
mulsd %xmm1, %xmm7
mulsd %xmm1, %xmm7
movsd 0xab1f(%rip), %xmm5     # 0x113c0
movsd 0xab27(%rip), %xmm3     # 0x113d0
movapd %xmm3, %xmm4
cmpnlesd %xmm1, %xmm4
addsd %xmm5, %xmm1
movsd 0xab0a(%rip), %xmm6     # 0x113c8
mulsd %xmm6, %xmm1
andpd %xmm4, %xmm1
andnpd %xmm7, %xmm4
orpd %xmm1, %xmm4
mulsd 0xaa9a(%rip), %xmm4     # 0x11370
addsd %xmm0, %xmm2
movapd %xmm0, %xmm7
mulsd %xmm0, %xmm7
mulsd %xmm0, %xmm7
movapd %xmm3, %xmm1
cmpnlesd %xmm0, %xmm1
addsd %xmm5, %xmm0
mulsd %xmm6, %xmm0
andpd %xmm1, %xmm0
andnpd %xmm7, %xmm1
orpd %xmm0, %xmm1
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm2, %xmm5
mulsd %xmm6, %xmm5
cmpnlesd %xmm2, %xmm3
andpd %xmm3, %xmm5
andnpd %xmm0, %xmm3
orpd %xmm5, %xmm3
mulsd 0xaa48(%rip), %xmm3     # 0x11378
movapd %xmm4, %xmm0
movapd %xmm3, %xmm2
jmp 0x5f67
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Xyz2Luv(double*, double*, double*, double, double, double)
void Xyz2Luv(num *L, num *u, num *v, num X, num Y, num Z)
{	
	num u1, v1, Denom;
	

	if((Denom = X + 15*Y + 3*Z) > 0)
	{
		u1 = (4*X) / Denom;
		v1 = (9*Y) / Denom;
	}
	else
		u1 = v1 = 0;

	Y /= WHITEPOINT_Y;
	Y = LABF(Y);
	*L = 116*Y - 16;
	*u = 13*(*L)*(u1 - WHITEPOINT_U);
	*v = 13*(*L)*(v1 - WHITEPOINT_V);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movapd %xmm1, %xmm3
movapd %xmm0, %xmm1
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movsd 0xb092(%rip), %xmm0     # 0x113d8
mulsd %xmm3, %xmm0
addsd %xmm1, %xmm0
mulsd 0xaf3a(%rip), %xmm2     # 0x11290
addsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x6382
unpcklpd %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0]
mulpd 0xb1e0(%rip), %xmm1     # 0x11550
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm1
addpd 0xb1c0(%rip), %xmm1     # 0x11540
jmp 0x638a
movapd 0xb1b6(%rip), %xmm1     # 0x11540
ucomisd 0xafee(%rip), %xmm3     # 0x11380
jae 0x63a6
mulsd 0xaff4(%rip), %xmm3     # 0x11390
addsd 0xaff4(%rip), %xmm3     # 0x11398
jmp 0x63c5
movapd %xmm1, (%rsp)
movsd 0xafd5(%rip), %xmm1     # 0x11388
movapd %xmm3, %xmm0
callq 0x2290
movapd (%rsp), %xmm1
movapd %xmm0, %xmm3
mulsd 0xafd3(%rip), %xmm3     # 0x113a0
addsd 0xacfb(%rip), %xmm3     # 0x110d0
movsd %xmm3, (%r14)
movsd 0xaffe(%rip), %xmm0     # 0x113e0
mulsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
movsd %xmm3, (%r15)
mulsd (%r14), %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
mulsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Luv2Xyz(double*, double*, double*, double, double, double)
void Luv2Xyz(num *X, num *Y, num *Z, num L, num u, num v)
{
	*Y = (L + 16)/116;
	*Y = WHITEPOINT_Y*LABINVF(*Y);
	
	if(L != 0)
	{
		u /= L;
		v /= L;
	}
	
	u = u/13 + WHITEPOINT_U;
	v = v/13 + WHITEPOINT_V;
	*X = (*Y) * ((9*u)/(4*v));
	*Z = (*Y) * ((3 - 0.75*u)/v - 5);
}

// Assembly:
movsd 0xac86(%rip), %xmm4     # 0x11098
addsd %xmm0, %xmm4
divsd 0xaf82(%rip), %xmm4     # 0x113a0
movapd %xmm4, %xmm5
mulsd %xmm4, %xmm5
mulsd %xmm4, %xmm5
movsd 0xaf8e(%rip), %xmm6     # 0x113c0
addsd %xmm4, %xmm6
mulsd 0xaf8a(%rip), %xmm6     # 0x113c8
movsd 0xaf8a(%rip), %xmm3     # 0x113d0
cmpnlesd %xmm4, %xmm3
movapd %xmm3, %xmm4
andnpd %xmm5, %xmm4
andpd %xmm6, %xmm3
orpd %xmm4, %xmm3
movlpd %xmm3, (%rsi)
xorpd %xmm4, %xmm4
cmpneqsd %xmm0, %xmm4
movq %xmm4, %rax
andl $0x1, %eax
punpcklqdq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0]
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movd %eax, %xmm2
pshufd $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
pslld $0x1f, %xmm2
psrad $0x1f, %xmm2
movdqa %xmm2, %xmm4
pandn %xmm1, %xmm4
divpd %xmm0, %xmm1
andpd %xmm2, %xmm1
orpd %xmm4, %xmm1
divpd 0xb0b9(%rip), %xmm1     # 0x11560
addpd 0xb0c1(%rip), %xmm1     # 0x11570
movapd 0xb0c9(%rip), %xmm0     # 0x11580
mulpd %xmm1, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
divsd %xmm2, %xmm0
mulsd %xmm3, %xmm0
movsd 0xaf15(%rip), %xmm2     # 0x113e8
mulsd %xmm1, %xmm2
addsd 0xadb1(%rip), %xmm2     # 0x11290
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
divsd %xmm1, %xmm2
addsd 0xaf01(%rip), %xmm2     # 0x113f0
movsd %xmm0, (%rdi)
mulsd (%rsi), %xmm2
movsd %xmm2, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Xyz2Lch(double*, double*, double*, double, double, double)
void Xyz2Lch(num *L, num *C, num *H, num X, num Y, num Z)
{
	num a, b;
	
	
	Xyz2Lab(L, &a, &b, X, Y, Z);
	*C = sqrt(a*a + b*b);
	*H = atan2(b, a)*180.0/M_PI;
	
	if(*H < 0)
		*H += 360;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movapd %xmm1, %xmm3
movq %rdx, %rbx
movq %rsi, %r14
divsd 0xae59(%rip), %xmm0     # 0x11370
movq %rdi, %r15
ucomisd 0xae5e(%rip), %xmm0     # 0x11380
jae 0x6536
mulsd 0xae64(%rip), %xmm0     # 0x11390
addsd 0xae64(%rip), %xmm0     # 0x11398
jmp 0x655b
movsd 0xae4a(%rip), %xmm1     # 0x11388
movsd %xmm3, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x2290
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
divsd 0xae15(%rip), %xmm2     # 0x11378
ucomisd 0xae15(%rip), %xmm3     # 0x11380
movsd %xmm0, 0x18(%rsp)
jae 0x6585
mulsd 0xae15(%rip), %xmm3     # 0x11390
addsd 0xae15(%rip), %xmm3     # 0x11398
jmp 0x65a6
movsd 0xadfb(%rip), %xmm1     # 0x11388
movapd %xmm3, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x2290
movsd 0x8(%rsp), %xmm2
movapd %xmm0, %xmm3
ucomisd 0xadd2(%rip), %xmm2     # 0x11380
jae 0x65c2
mulsd 0xadd8(%rip), %xmm2     # 0x11390
addsd 0xadd8(%rip), %xmm2     # 0x11398
jmp 0x65e3
movsd 0xadbe(%rip), %xmm1     # 0x11388
movapd %xmm2, %xmm0
movsd %xmm3, 0x10(%rsp)
callq 0x2290
movsd 0x10(%rsp), %xmm3
movapd %xmm0, %xmm2
movsd 0xadb5(%rip), %xmm0     # 0x113a0
mulsd %xmm3, %xmm0
addsd 0xaad9(%rip), %xmm0     # 0x110d0
movsd 0x18(%rsp), %xmm1
subsd %xmm3, %xmm1
mulsd 0xad9f(%rip), %xmm1     # 0x113a8
subsd %xmm2, %xmm3
mulsd 0xad9b(%rip), %xmm3     # 0x113b0
movsd %xmm0, (%r15)
movapd %xmm3, %xmm0
mulsd %xmm3, %xmm0
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
movsd %xmm0, (%r14)
movapd %xmm3, %xmm0
callq 0x2060
mulsd 0xadad(%rip), %xmm0     # 0x113f8
divsd 0xadad(%rip), %xmm0     # 0x11400
movsd 0xac15(%rip), %xmm1     # 0x11270
addsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movlpd %xmm3, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: ApplyColorTransform(colortransform, double*, double*, double*, double, double, double)
void ApplyColorTransform(colortransform Trans, 
	num *D0, num *D1, num *D2, num S0, num S1, num S2)
{
	switch(Trans.NumStages)
	{
	case 1:
		Trans.Fun[0](D0, D1, D2, S0, S1, S2);
		break;
	case 2:
		{
			num T0, T1, T2;
			Trans.Fun[0](&T0, &T1, &T2, S0, S1, S2);
			Trans.Fun[1](D0, D1, D2, T0, T1, T2);
		}
		break;
	default:
		*D0 = S0;
		*D1 = S1;
		*D2 = S2;
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rsp), %r12
movl (%r12), %eax
cmpl $0x2, %eax
je 0x725b
cmpl $0x1, %eax
jne 0x7295
movq 0x8(%r12), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rsp, %rdi
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r13, %rsi
movq %rbp, %rdx
callq *0x8(%r12)
movq %rsp, %rax
movsd (%rax), %xmm0
movsd (%r13), %xmm1
movsd (%rbp), %xmm2
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%r12)
jmp 0x72a3
movsd %xmm0, (%r15)
movsd %xmm1, (%r14)
movsd %xmm2, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq