LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Gammelkebab[P]GameOfLife/src/world/world.cpp
// Function: World::set_blocks()
void World::set_blocks()
{
    blocks = new Block **[rows];
    for (int row = 0; row < rows; row++)
    {
        blocks[row] = new Block *[cols];
        for (int col = 0; col < cols; col++)
        {
            int block_num = row * cols + col;
            blocks[row][col] = new Block(this, block_num);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0xfee4
movq -0x30(%rbp), %rax
movslq 0x10(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movq -0x30(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0xfed4
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x10(%rcx), %ecx
imull %ecx, %eax
movl -0x10(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl $0x30, %edi
callq 0x85a0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %edx
callq 0xf8e0
jmp 0xfe91
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xfe4e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x85c0
jmp 0xfeea
jmp 0xfed6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfdfb
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8a40
nopw %cs:(%rax,%rax)
// File: Gammelkebab[P]GameOfLife/src/world/world.cpp
// Function: World::is_worker(int)
bool World::is_worker(int proc_num)
{
    // Processor proc_num is a worker,
    // as long as it does not appear in the writer array
    for (int w = 0; w < writer_amt; w++)
    {
        if (writer_nums[w] == proc_num)
        {
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jge 0xff4d
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0xff40
movb $0x0, -0x1(%rbp)
jmp 0xff51
jmp 0xff42
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xff1a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: Gammelkebab[P]GameOfLife/src/world/world.cpp
// Function: World::print()
void World::print()
{
    printf("World:\n{\n");
    printf("\tPixels: \t%d x %d\n", width, height);
    printf("\tBlocks: \t%d x %d\n", cols, rows);
    printf("\tWorkers: \t%d\n", worker_amt);
    printf("\tTotal rounds: \t%d\n", total_rounds);
    printf("\n}\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1365(%rip), %rdi      # 0x11310
movb $0x0, %al
callq 0x8040
movq -0x10(%rbp), %rax
movl (%rax), %esi
movl 0x4(%rax), %edx
leaq 0x1358(%rip), %rdi      # 0x1131a
movb $0x0, %al
callq 0x8040
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x1353(%rip), %rdi      # 0x1132d
movb $0x0, %al
callq 0x8040
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0x1351(%rip), %rdi      # 0x11340
movb $0x0, %al
callq 0x8040
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0x134b(%rip), %rdi      # 0x1134f
movb $0x0, %al
callq 0x8040
leaq 0x1351(%rip), %rdi      # 0x11363
movb $0x0, %al
callq 0x8040
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x18f3
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x10c0
movq %rax, %rdi
leaq 0x176a(%rip), %rsi      # 0x304a
callq 0x10d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1898
movq -0x10(%rbp), %rdi
movq 0x46ca(%rip), %rsi      # 0x5fc8
callq 0x1100
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a40
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2a10
testb $0x1, %al
jne 0x194d
jmp 0x1983
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2a70
movq -0x28(%rbp), %rdi
movl (%rax), %esi
callq 0x1160
movq %rax, %rdi
leaq 0x16d7(%rip), %rsi      # 0x304a
callq 0x10d0
leaq -0x18(%rbp), %rdi
callq 0x2aa0
jmp 0x192d
movq -0x10(%rbp), %rdi
movq 0x463a(%rip), %rsi      # 0x5fc8
callq 0x1100
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: joakimkistowski[P]amd-disable-c6/amd-disable-c6.cpp
// Function: print_help()
void print_help() {
    std::cout << "Changes and reads the C6 state on AMD Zen (Epyc/Ryzen) processors." << std::endl;
    std::cout << std::endl <<  "Options:" << std::endl;
    std::cout << FLAG_HELP0 << " or " << FLAG_HELP1 << ": Print this help message." << std::endl;
    std::cout << FLAG_LIST0 << " or " << FLAG_LIST1 << ": List current C6 states." << std::endl;
    std::cout << FLAG_DISABLE << ": Disable C6 states. This is the default behavior." << std::endl;
    std::cout << FLAG_DISABLE_RETRY << ": Disable C6 states. On failure, retry up to "
        << MAX_RETRIES << " times and sleep " << RETRY_SLEEP_DURATION_S << " s between trys." << std::endl;
    std::cout << FLAG_ENABLE << ": Enable C6 states." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x5b6d(%rip), %rdi      # 0x8fc8
leaq 0x2d02(%rip), %rsi      # 0x6164
callq 0x21b0
movq %rax, %rdi
movq 0x5b3f(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq 0x5b4b(%rip), %rdi      # 0x8fc8
movq 0x5b2c(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq %rax, %rdi
leaq 0x2d14(%rip), %rsi      # 0x61a7
callq 0x21b0
movq %rax, %rdi
movq 0x5b0e(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq 0x5b1a(%rip), %rdi      # 0x8fc8
leaq 0x5d8b(%rip), %rsi      # 0x9240
callq 0x21a0
movq %rax, %rdi
leaq 0x2cec(%rip), %rsi      # 0x61b0
callq 0x21b0
movq %rax, %rdi
leaq 0x5d8d(%rip), %rsi      # 0x9260
callq 0x21a0
movq %rax, %rdi
leaq 0x2cd3(%rip), %rsi      # 0x61b5
callq 0x21b0
movq %rax, %rdi
movq 0x5abf(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq 0x5acb(%rip), %rdi      # 0x8fc8
leaq 0x5ddc(%rip), %rsi      # 0x92e0
callq 0x21a0
movq %rax, %rdi
leaq 0x2c9d(%rip), %rsi      # 0x61b0
callq 0x21b0
movq %rax, %rdi
leaq 0x5dde(%rip), %rsi      # 0x9300
callq 0x21a0
movq %rax, %rdi
leaq 0x2c9f(%rip), %rsi      # 0x61d0
callq 0x21b0
movq %rax, %rdi
movq 0x5a70(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq 0x5a7c(%rip), %rdi      # 0x8fc8
leaq 0x5d2d(%rip), %rsi      # 0x9280
callq 0x21a0
movq %rax, %rdi
leaq 0x2c88(%rip), %rsi      # 0x61ea
callq 0x21b0
movq %rax, %rdi
movq 0x5a3f(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq 0x5a4b(%rip), %rdi      # 0x8fc8
leaq 0x5d1c(%rip), %rsi      # 0x92a0
callq 0x21a0
movq %rax, %rdi
leaq 0x2c8a(%rip), %rsi      # 0x621d
callq 0x21b0
movq %rax, %rdi
movl $0x4, %esi
callq 0x22b0
movq %rax, %rdi
leaq 0x2c9c(%rip), %rsi      # 0x624b
callq 0x21b0
movq %rax, %rdi
movl $0x4, %esi
callq 0x22b0
movq %rax, %rdi
leaq 0x2c92(%rip), %rsi      # 0x625d
callq 0x21b0
movq %rax, %rdi
movq 0x59d6(%rip), %rsi      # 0x8fb0
callq 0x21f0
movq 0x59e2(%rip), %rdi      # 0x8fc8
leaq 0x5cd3(%rip), %rsi      # 0x92c0
callq 0x21a0
movq %rax, %rdi
leaq 0x2c72(%rip), %rsi      # 0x626e
callq 0x21b0
movq %rax, %rdi
movq 0x59a5(%rip), %rsi      # 0x8fb0
callq 0x21f0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: joakimkistowski[P]amd-disable-c6/amd-disable-c6.cpp
// Function: has_amd_cpu()
bool has_amd_cpu() {
    const std::string VENDOR_PREFIX = std::string("vendor_id");
    const std::string VENDOR_REQUIRED = std::string(": AuthenticAMD");
    bool has_amd = false;
    std::string line;
    std::ifstream cpuinfo("/proc/cpuinfo");
    if (cpuinfo.is_open()) {
        while (getline(cpuinfo,line)) {
            if (line.compare(0, VENDOR_PREFIX.length(), VENDOR_PREFIX) == 0
                && line.find(VENDOR_REQUIRED) != std::string::npos) {
                has_amd = true;
                break;
            }
        }
        cpuinfo.close();
  }
  return has_amd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
leaq -0x21(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0x23a0
movq -0x290(%rbp), %rdx
leaq 0x2a70(%rip), %rsi      # 0x62d9
leaq -0x20(%rbp), %rdi
callq 0x3ed0
jmp 0x3874
leaq -0x21(%rbp), %rdi
callq 0x2210
leaq -0x59(%rbp), %rdi
movq %rdi, -0x298(%rbp)
callq 0x23a0
movq -0x298(%rbp), %rdx
leaq 0x2a48(%rip), %rsi      # 0x62e3
leaq -0x58(%rbp), %rdi
callq 0x3ed0
jmp 0x38a6
leaq -0x59(%rbp), %rdi
callq 0x2210
movb $0x0, -0x5a(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x22c0
leaq 0x2a2f(%rip), %rsi      # 0x62f2
leaq -0x288(%rbp), %rdi
movl $0x8, %edx
callq 0x23c0
jmp 0x38d6
leaq -0x288(%rbp), %rdi
callq 0x2350
movb %al, -0x299(%rbp)
jmp 0x38ea
movb -0x299(%rbp), %al
testb $0x1, %al
jne 0x38f9
jmp 0x3a09
jmp 0x38fb
leaq -0x288(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2060
movq %rax, -0x2a8(%rbp)
jmp 0x3914
movq -0x2a8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2280
movb %al, -0x2a9(%rbp)
jmp 0x3932
movb -0x2a9(%rbp), %al
testb $0x1, %al
jne 0x3941
jmp 0x39f9
leaq -0x20(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
callq 0x2300
movq -0x2b8(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x80(%rbp), %rdi
callq 0x22a0
movl %eax, -0x2b0(%rbp)
jmp 0x3970
movl -0x2b0(%rbp), %eax
cmpl $0x0, %eax
jne 0x39f4
leaq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2410
cmpq $-0x1, %rax
je 0x39f4
movb $0x1, -0x5a(%rbp)
jmp 0x39f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x2210
jmp 0x3a65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x2210
jmp 0x3a5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x3a4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x288(%rbp), %rdi
callq 0x2080
jmp 0x3a4a
jmp 0x38fb
leaq -0x288(%rbp), %rdi
callq 0x2070
jmp 0x3a07
jmp 0x3a09
movb -0x5a(%rbp), %al
movb %al, -0x2b9(%rbp)
leaq -0x288(%rbp), %rdi
callq 0x2080
leaq -0x80(%rbp), %rdi
callq 0x2428
leaq -0x58(%rbp), %rdi
callq 0x2428
leaq -0x20(%rbp), %rdi
callq 0x2428
movb -0x2b9(%rbp), %al
andb $0x1, %al
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
leaq -0x80(%rbp), %rdi
callq 0x2428
leaq -0x58(%rbp), %rdi
callq 0x2428
leaq -0x20(%rbp), %rdi
callq 0x2428
movq -0x30(%rbp), %rdi
callq 0x2390
nop
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x3a70
cmpl $0x0, %eax
je 0x3e34
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jae 0x3ded
movq 0x5253(%rip), %rdi      # 0x8fc8
leaq 0x2609(%rip), %rsi      # 0x6385
callq 0x21b0
movq %rax, %rdi
movl $0x4, %esi
callq 0x22b0
movq %rax, %rdi
leaq 0x2615(%rip), %rsi      # 0x63ad
callq 0x21b0
movq %rax, %rdi
movq 0x5209(%rip), %rsi      # 0x8fb0
callq 0x21f0
movl $0x4, %edi
callq 0x2150
movl $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3a70
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3dd4
jmp 0x3ddd
movl $0x0, -0x4(%rbp)
jmp 0x3e3b
jmp 0x3ddf
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3d68
movq 0x51fc(%rip), %rdi      # 0x8ff0
leaq 0x25bb(%rip), %rsi      # 0x63b6
callq 0x21b0
movq %rax, %rdi
movl $0x4, %esi
callq 0x22b0
movq %rax, %rdi
leaq 0x25c4(%rip), %rsi      # 0x63db
callq 0x21b0
movq %rax, %rdi
movq 0x518a(%rip), %rsi      # 0x8fb0
callq 0x21f0
movl $0x1, -0x4(%rbp)
jmp 0x3e3b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3840
testb $0x1, %al
jne 0x3e9a
movq 0x517a(%rip), %rdi      # 0x8ff0
leaq 0x2572(%rip), %rsi      # 0x63ef
callq 0x21b0
movq %rax, %rdi
movq 0x5124(%rip), %rsi      # 0x8fb0
callq 0x21f0
movl $0x1, -0x4(%rbp)
jmp 0x3ec5
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x3620
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x3eb9
callq 0x3d40
movl %eax, -0x4(%rbp)
jmp 0x3ec5
leaq -0x14(%rbp), %rdi
callq 0x3a70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: superyuan[P]refeditor/MappingConvertor.cpp
// Function: mapExtendedChrome(GenomePosition&)
int mapExtendedChrome(GenomePosition &gp2)
{
    int target = gp2.pos+readLength/2; //the middle of the read, in case the read overlap with 2 mini chromosomes.
    if (chrMap[gp2.chrName] != NULL)
	{
		vector<posMap> *v = chrMap[gp2.chrName];
		int min=0;
		int max=v->size()-1;
		int middle = (min+max+1)/2;

		while(min != max) {
			if ((*v)[middle].from <= target) {
				min=middle;
			} else {
				max=middle-1;
			}
			middle = (min+max+1)/2;
		}
		int offset = 0;
		if ( (*v)[min].from <= target)
			offset = (*v)[min].from - (*v)[min].to;
		gp2.pos -= offset;
	}
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x2c(%rbp)
movl 0xcb98(%rip), %eax      # 0x105b4
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xcb7f(%rip), %rdi      # 0x105b8
callq 0x4cd0
cmpq $0x0, (%rax)
je 0x3b22
movq -0x8(%rbp), %rsi
leaq 0xcb65(%rip), %rdi      # 0x105b8
callq 0x4cd0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4e70
subq $0x1, %rax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x3acd
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x4ea0
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jg 0x3aae
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ab7
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
jmp 0x3a8a
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4ea0
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jg 0x3b13
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4ea0
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4ea0
movq %rax, %rcx
movl -0x30(%rbp), %eax
subl 0x8(%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: superyuan[P]refeditor/MappingConvertor.cpp
// Function: parseParameters(int, char**)
static bool parseParameters (int argc, char *argv[])
{
	int c;
	while ((c = getopt (argc, argv, "i:m:o:")) != -1) {
		switch(c) {
			case 'i':
				strcpy(inputSamFileName, optarg);
				break;
			case 'm':
				strcpy(dipmapFileName, optarg);
				break;
			case 'o':
				strcpy(outputSamFileName, optarg);
				break;
			case '?':
				return false;
				break;
		}
	}  
	if (strlen(inputSamFileName)==0 || strlen(dipmapFileName)==0 || strlen(outputSamFileName)==0)
		return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x6722(%rip), %rdx      # 0xb1ff
callq 0x30a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x4b68
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x3f, %eax
je 0x4b5d
jmp 0x4af7
movl -0x18(%rbp), %eax
subl $0x69, %eax
je 0x4b15
jmp 0x4b01
movl -0x18(%rbp), %eax
subl $0x6d, %eax
je 0x4b2d
jmp 0x4b0b
movl -0x18(%rbp), %eax
subl $0x6f, %eax
je 0x4b45
jmp 0x4b63
movq 0xb4a4(%rip), %rax      # 0xffc0
movq (%rax), %rsi
leaq 0xb78a(%rip), %rdi      # 0x102b0
callq 0x3210
jmp 0x4b63
movq 0xb48c(%rip), %rax      # 0xffc0
movq (%rax), %rsi
leaq 0xb972(%rip), %rdi      # 0x104b0
callq 0x3210
jmp 0x4b63
movq 0xb474(%rip), %rax      # 0xffc0
movq (%rax), %rsi
leaq 0xb85a(%rip), %rdi      # 0x103b0
callq 0x3210
jmp 0x4b63
movb $0x0, -0x1(%rbp)
jmp 0x4ba8
jmp 0x4acf
leaq 0xb741(%rip), %rdi      # 0x102b0
callq 0x3110
cmpq $0x0, %rax
je 0x4b9e
leaq 0xb92f(%rip), %rdi      # 0x104b0
callq 0x3110
cmpq $0x0, %rax
je 0x4b9e
leaq 0xb81d(%rip), %rdi      # 0x103b0
callq 0x3110
cmpq $0x0, %rax
jne 0x4ba4
movb $0x0, -0x1(%rbp)
jmp 0x4ba8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kuszmaul[P]6886/rdtsc.c
// Function: main
int main (int argc __attribute__((unused)), char *argv[] __attribute__((unused))) {
    struct timespec start, end;
    {
	int r = clock_gettime(CLOCK_MONOTONIC, &start);
	assert(r==0);
    }
    int N = 10000000;
    unsigned long long vv=0;
    for (int i=0; i<N; i++) {
	vv += rdtsc();
    }
    clock_gettime(CLOCK_MONOTONIC, &end);
    double tdiff = ((end.tv_sec-start.tv_sec)
		    + 1e-9*(end.tv_nsec-start.tv_nsec));
    printf("vv=%llu\n", vv);
    printf("Time %.6fs (%gns per call to clock_gettime(CLOCK_MONOTONIC,...)\n",
	   tdiff, 1e9*(tdiff/(double)N));
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
leaq -0x20(%rbp), %rsi
callq 0x1030
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x118f
jmp 0x11ae
leaq 0xe82(%rip), %rdi       # 0x2018
leaq 0xe80(%rip), %rsi       # 0x201d
movl $0x12, %edx
leaq 0xe7c(%rip), %rcx       # 0x2025
callq 0x1050
movl $0x989680, -0x38(%rbp)  # imm = 0x989680
movq $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x11e4
callq 0x1270
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x11c4
movl $0x1, %edi
leaq -0x30(%rbp), %rsi
callq 0x1030
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm1
movq -0x28(%rbp), %rax
subq -0x18(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0xdfc(%rip), %xmm2      # 0x2010
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x40(%rbp), %rsi
leaq 0xe10(%rip), %rdi       # 0x203c
movb $0x0, %al
callq 0x1040
movsd -0x50(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
cvtsi2sdl -0x38(%rbp), %xmm1
divsd %xmm1, %xmm2
movsd 0xdba(%rip), %xmm1      # 0x2008
mulsd %xmm2, %xmm1
leaq 0xdec(%rip), %rdi       # 0x2045
movb $0x2, %al
callq 0x1040
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kuszmaul[P]6886/rdtsc.c
// Function: rdtsc
static __inline__ unsigned long long rdtsc(void)
{
  unsigned hi, lo;
  __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
  return (   ((unsigned long long)lo)
	  | (((unsigned long long)hi)<<32));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
rdtsc
movl %eax, -0x8(%rbp)
movl %edx, -0x4(%rbp)
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x157c1(%rip), %rsi     # 0x1d5d4
callq 0x22a0
cmpl $0x0, %eax
jne 0x7e60
movq -0x18(%rbp), %rcx
leaq 0x157ac(%rip), %rax     # 0x1d5d4
movq %rax, (%rcx)
movl $0x1, 0x10(%rcx)
movl $0x200, 0x8(%rcx)       # imm = 0x200
movl $0x200, 0xc(%rcx)       # imm = 0x200
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
imull 0x10(%rcx), %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x7ea1
movq -0x18(%rbp), %rcx
leaq 0x1477d(%rip), %rax     # 0x1c5e8
movq %rax, (%rcx)
movl $0x3, 0x10(%rcx)
movl $0x200, 0x8(%rcx)       # imm = 0x200
movl $0x200, 0xc(%rcx)       # imm = 0x200
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
imull 0x10(%rcx), %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x156fb(%rip), %rsi     # 0x1d5d4
callq 0x22a0
cmpl $0x0, %eax
jne 0x7f24
movq -0x20(%rbp), %rcx
leaq 0x156e6(%rip), %rax     # 0x1d5d4
movq %rax, (%rcx)
movl $0x1, 0x10(%rcx)
movl -0x14(%rbp), %eax
movl %eax, 0x8(%rcx)
movl -0x18(%rbp), %eax
movl %eax, 0xc(%rcx)
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
imull 0x10(%rcx), %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x7f63
movq -0x20(%rbp), %rcx
leaq 0x146b9(%rip), %rax     # 0x1c5e8
movq %rax, (%rcx)
movl $0x3, 0x10(%rcx)
movl -0x14(%rbp), %eax
movl %eax, 0x8(%rcx)
movl -0x18(%rbp), %eax
movl %eax, 0xc(%rcx)
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
imull 0x10(%rcx), %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rdi
leaq 0x14650(%rip), %rsi     # 0x1c5e8
callq 0x22a0
cmpl $0x0, %eax
jne 0x8052
movq -0x10(%rbp), %rdi
leaq 0x1463d(%rip), %rsi     # 0x1c5ee
callq 0x2230
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x7ff8
movq 0x19001(%rip), %rdi     # 0x20fc8
leaq 0x14623(%rip), %rsi     # 0x1c5f1
callq 0x21c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x21c0
movq %rax, %rdi
movq 0x18fcf(%rip), %rsi     # 0x20fb8
callq 0x21e0
movl $0x1, %edi
callq 0x2240
movq -0x30(%rbp), %rcx
movq 0x18(%rcx), %rdi
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
imull 0x10(%rcx), %eax
movslq %eax, %rdx
movq -0x20(%rbp), %rcx
movl $0x4, %esi
callq 0x22d0
cmpq $0x0, %rax
jne 0x8044
movq 0x18f9f(%rip), %rdi     # 0x20fc8
leaq 0x145d4(%rip), %rsi     # 0x1c604
callq 0x21c0
movq %rax, %rdi
movq 0x18f79(%rip), %rsi     # 0x20fb8
callq 0x21e0
movq -0x20(%rbp), %rdi
callq 0x21d0
jmp 0x813b
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0x15574(%rip), %rsi     # 0x1d5d4
callq 0x22a0
cmpl $0x0, %eax
jne 0x8117
movq -0x10(%rbp), %rdi
leaq 0x14575(%rip), %rsi     # 0x1c5ee
callq 0x2230
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x80c0
movq 0x18f39(%rip), %rdi     # 0x20fc8
leaq 0x1455b(%rip), %rsi     # 0x1c5f1
callq 0x21c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x21c0
movq %rax, %rdi
movq 0x18f07(%rip), %rsi     # 0x20fb8
callq 0x21e0
movl $0x1, %edi
callq 0x2240
movq -0x30(%rbp), %rcx
movq 0x18(%rcx), %rdi
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
imull 0x10(%rcx), %eax
movslq %eax, %rdx
movq -0x28(%rbp), %rcx
movl $0x4, %esi
callq 0x22d0
cmpq $0x0, %rax
jne 0x810c
movq 0x18ed7(%rip), %rdi     # 0x20fc8
leaq 0x1450c(%rip), %rsi     # 0x1c604
callq 0x21c0
movq %rax, %rdi
movq 0x18eb1(%rip), %rsi     # 0x20fb8
callq 0x21e0
movq -0x28(%rbp), %rdi
callq 0x21d0
jmp 0x8139
movq 0x18eaa(%rip), %rdi     # 0x20fc8
leaq 0x144ed(%rip), %rsi     # 0x1c612
callq 0x21c0
movq %rax, %rdi
movq 0x18e84(%rip), %rsi     # 0x20fb8
callq 0x21e0
jmp 0x813b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rdi
leaq 0x14470(%rip), %rsi     # 0x1c5e8
callq 0x22a0
cmpl $0x0, %eax
jne 0x8232
movq -0x10(%rbp), %rdi
leaq 0x14498(%rip), %rsi     # 0x1c629
callq 0x2230
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x81d8
movq 0x18e21(%rip), %rdi     # 0x20fc8
leaq 0x14443(%rip), %rsi     # 0x1c5f1
callq 0x21c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x21c0
movq %rax, %rdi
movq 0x18def(%rip), %rsi     # 0x20fb8
callq 0x21e0
movl $0x1, %edi
callq 0x2240
movq -0x30(%rbp), %rcx
movq 0x18(%rcx), %rdi
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
imull 0x10(%rcx), %eax
movslq %eax, %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x23d0
cmpq $0x0, %rax
jne 0x8224
movq 0x18dbf(%rip), %rdi     # 0x20fc8
leaq 0x1441c(%rip), %rsi     # 0x1c62c
callq 0x21c0
movq %rax, %rdi
movq 0x18d99(%rip), %rsi     # 0x20fb8
callq 0x21e0
movq -0x20(%rbp), %rdi
callq 0x21d0
jmp 0x82f7
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0x15394(%rip), %rsi     # 0x1d5d4
callq 0x22a0
cmpl $0x0, %eax
jne 0x82f5
movq -0x10(%rbp), %rdi
leaq 0x143d0(%rip), %rsi     # 0x1c629
callq 0x2230
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x82a0
movq 0x18d59(%rip), %rdi     # 0x20fc8
leaq 0x1437b(%rip), %rsi     # 0x1c5f1
callq 0x21c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x21c0
movq %rax, %rdi
movq 0x18d27(%rip), %rsi     # 0x20fb8
callq 0x21e0
movl $0x1, %edi
callq 0x2240
movq -0x30(%rbp), %rcx
movq 0x18(%rcx), %rdi
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
imull 0x10(%rcx), %eax
movslq %eax, %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x23d0
cmpq $0x0, %rax
jne 0x82ec
movq 0x18cf7(%rip), %rdi     # 0x20fc8
leaq 0x14354(%rip), %rsi     # 0x1c62c
callq 0x21c0
movq %rax, %rdi
movq 0x18cd1(%rip), %rsi     # 0x20fb8
callq 0x21e0
movq -0x28(%rbp), %rdi
callq 0x21d0
jmp 0x82f7
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rishabh-battulwar[P]imageprocessing/./include/Image.h
// Function: Image::operator()(int, int, int)
int Image::operator()(int K, int L, int M)
{
	if(!(strcmp(imgtype, "color")))
  	return (int)imgdata[(K)*cols*channels + (L)*channels + M];
  if(!(strcmp(imgtype, "bw")))
  	return (int)imgdata[(K)*cols*channels + (L)*channels + M];
  else
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
leaq 0x142c1(%rip), %rsi     # 0x1c5e8
callq 0x22a0
cmpl $0x0, %eax
jne 0x835c
movq -0x28(%rbp), %rsi
movq 0x18(%rsi), %rax
movl -0x14(%rbp), %ecx
imull 0x8(%rsi), %ecx
imull 0x10(%rsi), %ecx
movl -0x18(%rbp), %edx
imull 0x10(%rsi), %edx
addl %edx, %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x83a6
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq 0x1526a(%rip), %rsi     # 0x1d5d4
callq 0x22a0
cmpl $0x0, %eax
jne 0x839f
movq -0x28(%rbp), %rsi
movq 0x18(%rsi), %rax
movl -0x14(%rbp), %ecx
imull 0x8(%rsi), %ecx
imull 0x10(%rsi), %ecx
movl -0x18(%rbp), %edx
imull 0x10(%rsi), %edx
addl %edx, %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x83a6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
movq (%rsi), %rsi
callq 0x21a0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
movl %ecx, 0xc(%rsi)
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rsi)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsi)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x851f
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x850f
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x8502
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x83b0
movq -0x30(%rbp), %rdi
movl -0x3c(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0x34(%rbp), %ecx
movl %eax, %r8d
callq 0x83f0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x84b2
jmp 0x8504
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x849f
jmp 0x8511
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8488
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x13844(%rip), %xmm1    # 0x1c0b0
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x137fe(%rip), %xmm1    # 0x1c080
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x137e8(%rip), %xmm1    # 0x1c080
subsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm1
movsd 0x13852(%rip), %xmm0    # 0x1c100
mulsd -0x28(%rbp), %xmm0
movsd 0x1381d(%rip), %xmm2    # 0x1c0d8
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movsd 0x13828(%rip), %xmm2    # 0x1c0f8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm1
movsd 0x13803(%rip), %xmm0    # 0x1c0f0
mulsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x137c7(%rip), %xmm2    # 0x1c0d8
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movsd 0x137c2(%rip), %xmm2    # 0x1c0e8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm1
movsd 0x1379d(%rip), %xmm0    # 0x1c0e0
mulsd -0x28(%rbp), %xmm0
movsd 0x13788(%rip), %xmm2    # 0x1c0d8
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movsd 0x1376b(%rip), %xmm2    # 0x1c0d0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
addsd %xmm1, %xmm1
addsd %xmm0, %xmm1
subsd -0x30(%rbp), %xmm1
movsd 0x1266f(%rip), %xmm0    # 0x1c108
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm1
subsd -0x30(%rbp), %xmm1
movsd 0x127cc(%rip), %xmm0    # 0x1c280
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd 0x127a4(%rip), %xmm1    # 0x1c278
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9bce
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x9b37
movsd -0x20(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x9b21
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x9b2b
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
jmp 0x9b67
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x9b53
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
jmp 0x9b5d
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm1
movq -0x18(%rbp), %rax
divsd (%rax), %xmm1
movsd 0x126ec(%rip), %xmm0    # 0x1c268
subsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
callq 0x2060
movsd 0x126e9(%rip), %xmm1    # 0x1c288
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0x9bcc
movq -0x8(%rbp), %rax
movsd 0x12694(%rip), %xmm0    # 0x1c258
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x9be4
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd 0x1232d(%rip), %xmm0    # 0x1c2a8
ucomisd -0x20(%rbp), %xmm0
jb 0x9f9a
movsd -0x20(%rbp), %xmm0
movsd 0x12339(%rip), %xmm1    # 0x1c2c8
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x9fc5
movsd 0x1231e(%rip), %xmm0    # 0x1c2c0
addsd -0x20(%rbp), %xmm0
movsd 0x12309(%rip), %xmm1    # 0x1c2b8
divsd %xmm1, %xmm0
movsd 0x122f5(%rip), %xmm1    # 0x1c2b0
callq 0x2350
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x122d1(%rip), %xmm0    # 0x1c2a8
ucomisd -0x28(%rbp), %xmm0
jb 0x9ff6
movsd -0x28(%rbp), %xmm0
movsd 0x122dd(%rip), %xmm1    # 0x1c2c8
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0xa021
movsd 0x122c2(%rip), %xmm0    # 0x1c2c0
addsd -0x28(%rbp), %xmm0
movsd 0x122ad(%rip), %xmm1    # 0x1c2b8
divsd %xmm1, %xmm0
movsd 0x12299(%rip), %xmm1    # 0x1c2b0
callq 0x2350
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x12275(%rip), %xmm0    # 0x1c2a8
ucomisd -0x30(%rbp), %xmm0
jb 0xa052
movsd -0x30(%rbp), %xmm0
movsd 0x12281(%rip), %xmm1    # 0x1c2c8
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0xa07d
movsd 0x12266(%rip), %xmm0    # 0x1c2c0
addsd -0x30(%rbp), %xmm0
movsd 0x12251(%rip), %xmm1    # 0x1c2b8
divsd %xmm1, %xmm0
movsd 0x1223d(%rip), %xmm1    # 0x1c2b0
callq 0x2350
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm1
movsd 0x1227c(%rip), %xmm0    # 0x1c310
mulsd -0x28(%rbp), %xmm0
movsd 0x12267(%rip), %xmm2    # 0x1c308
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movsd 0x1224a(%rip), %xmm2    # 0x1c300
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm1
movsd 0x12225(%rip), %xmm0    # 0x1c2f8
mulsd -0x28(%rbp), %xmm0
movsd 0x12210(%rip), %xmm2    # 0x1c2f0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movsd 0x121f3(%rip), %xmm2    # 0x1c2e8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm1
movsd 0x121ce(%rip), %xmm0    # 0x1c2e0
mulsd -0x28(%rbp), %xmm0
movsd 0x121b9(%rip), %xmm2    # 0x1c2d8
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movsd 0x1219c(%rip), %xmm2    # 0x1c2d0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x11f18(%rip), %xmm1    # 0x1c388
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x11de2(%rip), %xmm1    # 0x1c268
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x11ee4(%rip), %xmm1    # 0x1c380
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x11ec6(%rip), %xmm1    # 0x1c378
ucomisd %xmm1, %xmm0
jb 0xa4d1
movsd -0x20(%rbp), %xmm0
movsd 0x11edb(%rip), %xmm1    # 0x1c3a0
callq 0x2350
movsd %xmm0, -0x38(%rbp)
jmp 0xa4f3
movsd -0x20(%rbp), %xmm0
movsd 0x11eb2(%rip), %xmm1    # 0x1c390
mulsd %xmm1, %xmm0
movsd 0x11eae(%rip), %xmm1    # 0x1c398
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x11e6e(%rip), %xmm1    # 0x1c378
ucomisd %xmm1, %xmm0
jb 0xa529
movsd -0x28(%rbp), %xmm0
movsd 0x11e83(%rip), %xmm1    # 0x1c3a0
callq 0x2350
movsd %xmm0, -0x40(%rbp)
jmp 0xa54b
movsd -0x28(%rbp), %xmm0
movsd 0x11e5a(%rip), %xmm1    # 0x1c390
mulsd %xmm1, %xmm0
movsd 0x11e56(%rip), %xmm1    # 0x1c398
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x11e16(%rip), %xmm1    # 0x1c378
ucomisd %xmm1, %xmm0
jb 0xa581
movsd -0x30(%rbp), %xmm0
movsd 0x11e2b(%rip), %xmm1    # 0x1c3a0
callq 0x2350
movsd %xmm0, -0x48(%rbp)
jmp 0xa5a3
movsd -0x30(%rbp), %xmm0
movsd 0x11e02(%rip), %xmm1    # 0x1c390
mulsd %xmm1, %xmm0
movsd 0x11dfe(%rip), %xmm1    # 0x1c398
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x11dfe(%rip), %xmm1    # 0x1c3b8
mulsd %xmm1, %xmm0
movsd 0x11dfa(%rip), %xmm1    # 0x1c3c0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm1
subsd -0x28(%rbp), %xmm1
movsd 0x11dcc(%rip), %xmm0    # 0x1c3b0
mulsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm1
subsd -0x30(%rbp), %xmm1
movsd 0x11da6(%rip), %xmm0    # 0x1c3a8
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rishabh-battulwar[P]imageprocessing/./include/colorspace.h
// Function: Lab2Xyz(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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd 0x11a69(%rip), %xmm0    # 0x1c0b0
addsd -0x20(%rbp), %xmm0
movsd 0x11d64(%rip), %xmm1    # 0x1c3b8
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd 0x11d41(%rip), %xmm2    # 0x1c3b0
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd 0x11d1a(%rip), %xmm2    # 0x1c3a8
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x11d20(%rip), %xmm1    # 0x1c3c8
ucomisd %xmm1, %xmm0
jb 0xa6c4
movsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0xa6e6
movsd -0x28(%rbp), %xmm1
movsd 0x11cc7(%rip), %xmm0    # 0x1c398
subsd %xmm0, %xmm1
movsd 0x11cf3(%rip), %xmm0    # 0x1c3d0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd 0x11c95(%rip), %xmm0    # 0x1c388
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd 0x11cbc(%rip), %xmm1    # 0x1c3c8
ucomisd %xmm1, %xmm0
jb 0xa728
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0xa74a
movsd -0x20(%rbp), %xmm1
movsd 0x11c63(%rip), %xmm0    # 0x1c398
subsd %xmm0, %xmm1
movsd 0x11c8f(%rip), %xmm0    # 0x1c3d0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm1
movsd 0x11b11(%rip), %xmm0    # 0x1c268
mulsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movsd 0x11c58(%rip), %xmm1    # 0x1c3c8
ucomisd %xmm1, %xmm0
jb 0xa78c
movsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0xa7ae
movsd -0x30(%rbp), %xmm1
movsd 0x11bff(%rip), %xmm0    # 0x1c398
subsd %xmm0, %xmm1
movsd 0x11c2b(%rip), %xmm0    # 0x1c3d0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm1
movsd 0x11bc5(%rip), %xmm0    # 0x1c380
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
popq %rbp
retq
nopl (%rax)