LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: codebrainz[P]libutfxx/utf/./utfstring.h
// Function: utf::operator<<(std::ostream&, utf::string<char> const&)
inline friend std::ostream& operator<<(std::ostream& out, const string<char_type>& str)
	{
		std::basic_string<std::ostream::char_type> out_str;
		utf::convert(str.str(), out_str);
		out << out_str.c_str();
		return out;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3200
movq -0x10(%rbp), %rdi
callq 0x4e50
movq %rax, -0x48(%rbp)
jmp 0x3998
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3760
jmp 0x39a7
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3070
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x3120
jmp 0x39c6
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30a0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30a0
movq -0x38(%rbp), %rdi
callq 0x3250
nop
// File: codebrainz[P]libutfxx/utf/./utfstring.h
// Function: utf::string<char>& utf::string<char>::append<char const*>(char const*)
string& append(T str) {
		string_type tmp;
		utf::convert(str, tmp);
		s += tmp;
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3200
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3260
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x4a30
jmp 0x4dbc
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3760
jmp 0x4dcb
leaq -0x50(%rbp), %rdi
callq 0x30a0
leaq -0x51(%rbp), %rdi
callq 0x3180
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31e0
jmp 0x4dec
leaq -0x30(%rbp), %rdi
callq 0x30a0
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4e25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x30a0
leaq -0x51(%rbp), %rdi
callq 0x3180
jmp 0x4e3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30a0
movq -0x60(%rbp), %rdi
callq 0x3250
nop
// File: tomfunkhouser[P]gaps/apps/img2pd/img2pd.cpp
// Function: AddImageToPixelDatabase(gaps::R2PixelDatabase&, char const*)
static int
AddImageToPixelDatabase(R2PixelDatabase& pd, const char *image_filename)
{
  // Add image to pixel database
  R2Image image;
  if (!image.ReadFile(image_filename)) return 0;
  pd.InsertImage(image_filename, image);

  // Increment image counter
  image_count++;

  // Print message
  if (print_debug) {
    printf("  %s\n", image_filename);
    fflush(stdout);
  }
  
  // Return success
  return 1;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd460
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xd4e0
movl %eax, 0x14(%rsp)
jmp 0x6ec2
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
jne 0x6efa
movl $0x0, 0x54(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x6f64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xdeb0
jmp 0x6f77
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq (%rdi), %rax
movq 0x30(%rax), %rax
leaq 0x28(%rsp), %rdx
callq *%rax
jmp 0x6f14
movl 0xb858e(%rip), %eax     # 0xbf4a8
addl $0x1, %eax
movl %eax, 0xb8585(%rip)     # 0xbf4a8
cmpl $0x0, 0xb8582(%rip)     # 0xbf4ac
je 0x6f54
movq 0x40(%rsp), %rsi
leaq 0x991ea(%rip), %rdi     # 0xa0122
xorl %eax, %eax
callq 0x5060
jmp 0x6f41
movq 0xb8068(%rip), %rax     # 0xbefb0
movq (%rax), %rdi
callq 0x5440
jmp 0x6f52
jmp 0x6f54
movl $0x1, 0x54(%rsp)
movl $0x1, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xdeb0
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/img2pd/img2pd.cpp
// Function: AddListToPixelDatabase(gaps::R2PixelDatabase&, char const*)
static int
AddListToPixelDatabase(R2PixelDatabase& pd, const char *list_filename)
{
  // Open list of images
  FILE *fp = fopen(list_filename, "r");
  if (!fp) {
    RNFail("Unable to open list of images: %s", list_filename);
    return 0;
  }

  // Add images to pixel database
  char image_filename[4096];
  while (fscanf(fp, "%s", image_filename) == (unsigned int) 1) {
    if (!AddImageToPixelDatabase(pd, image_filename)) return 0;
  }

  // Close list of images
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, 0x1018(%rsp)
movq %rsi, 0x1010(%rsp)
movq 0x1010(%rsp), %rdi
leaq 0x9c25d(%rip), %rsi     # 0xa3213
callq 0x5450
movq %rax, 0x1008(%rsp)
cmpq $0x0, 0x1008(%rsp)
jne 0x6ff1
movq 0x1010(%rsp), %rsi
leaq 0x9914b(%rip), %rdi     # 0xa0128
movb $0x0, %al
callq 0x424c0
movl $0x0, 0x1024(%rsp)
jmp 0x704d
jmp 0x6ff3
movq 0x1008(%rsp), %rdi
movq %rsp, %rdx
leaq 0x99457(%rip), %rsi     # 0xa045c
movb $0x0, %al
callq 0x56e0
cmpl $0x1, %eax
jne 0x7035
movq 0x1018(%rsp), %rdi
movq %rsp, %rsi
callq 0x6e90
cmpl $0x0, %eax
jne 0x7033
movl $0x0, 0x1024(%rsp)
jmp 0x704d
jmp 0x6ff3
movq 0x1008(%rsp), %rdi
callq 0x5380
movl $0x1, 0x1024(%rsp)
movl 0x1024(%rsp), %eax
addq $0x1028, %rsp           # imm = 0x1028
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/img2pd/img2pd.cpp
// Function: AddDirectoryToPixelDatabase(gaps::R2PixelDatabase&, char const*)
static int
AddDirectoryToPixelDatabase(R2PixelDatabase& pd, const char *directory_name)
{
  // Open directory
  DIR *dir = opendir(directory_name);
  if (!dir) {
    RNFail("Unable to open directory %s\n", directory_name);
    return 0;
  }

  // Read directory contents
  for (struct dirent *entry = readdir(dir); entry; entry = readdir(dir)) {
    char path_name[4096];
    const char *entry_name = entry->d_name;
    if (entry_name[0] == '.') continue;
    sprintf(path_name, "%s/%s", directory_name, entry_name);
    if (!AddImageToPixelDatabase(pd, path_name)) return 0;
   }

  // Close directory
  closedir(dir);

  // Return success
  return 1;
}

// Assembly:
subq $0x1038, %rsp           # imm = 0x1038
movq %rdi, 0x1028(%rsp)
movq %rsi, 0x1020(%rsp)
movq 0x1020(%rsp), %rdi
callq 0x55d0
movq %rax, 0x1018(%rsp)
cmpq $0x0, 0x1018(%rsp)
jne 0x70bd
movq 0x1020(%rsp), %rsi
leaq 0x990a4(%rip), %rdi     # 0xa014a
movb $0x0, %al
callq 0x424c0
movl $0x0, 0x1034(%rsp)
jmp 0x7179
movq 0x1018(%rsp), %rdi
callq 0x55e0
movq %rax, 0x1010(%rsp)
cmpq $0x0, 0x1010(%rsp)
je 0x7161
movq 0x1010(%rsp), %rax
addq $0x13, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x7101
jmp 0x7147
leaq 0x10(%rsp), %rdi
movq 0x1020(%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x9904d(%rip), %rsi     # 0xa0167
movb $0x0, %al
callq 0x50c0
movq 0x1028(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6e90
cmpl $0x0, %eax
jne 0x7145
movl $0x0, 0x1034(%rsp)
jmp 0x7179
jmp 0x7147
movq 0x1018(%rsp), %rdi
callq 0x55e0
movq %rax, 0x1010(%rsp)
jmp 0x70d2
movq 0x1018(%rsp), %rdi
callq 0x5640
movl $0x1, 0x1034(%rsp)
movl 0x1034(%rsp), %eax
addq $0x1038, %rsp           # imm = 0x1038
retq
nopl (%rax,%rax)
// File: EDDRSoftware[P]libdefsEval/main.cpp
// Function: readUntilEOL(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void readUntilEOL(stringstream *stream, string *outVar)
{
    string buffer;

    getline(*stream, buffer);
    // getline does not trim the beginning of line.  There is usually whitespace.
    buffer.erase(buffer.begin(), find_if(buffer.begin(), buffer.end(),
                                         not1(ptr_fun<int, int>(isspace))));
    *outVar = buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x6600
movq -0x90(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x6080
jmp 0x70b5
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x63d0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa620
movq -0xa0(%rbp), %rdi
callq 0x63d0
movq -0xa0(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x6260
movq %rax, -0x70(%rbp)
movq 0x19e6b(%rip), %rdi     # 0x20f68
callq 0xa6f0
movq %rax, -0x98(%rbp)
jmp 0x710b
movq -0x98(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xa6c0
movq %rax, -0xa8(%rbp)
jmp 0x7128
movq -0xa8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0xa660
movq %rax, -0xb0(%rbp)
jmp 0x714d
movq -0xb0(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa620
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x6090
movq %rax, -0xb8(%rbp)
jmp 0x717f
movq -0xb8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6040
jmp 0x719c
leaq -0x30(%rbp), %rdi
callq 0x6290
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6290
movq -0x38(%rbp), %rdi
callq 0x6780
nopl (%rax)
// File: EDDRSoftware[P]libdefsEval/main.cpp
// Function: isRecursiveInclude(boost::filesystem::path const&, 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>>>>*)
bool
isRecursiveInclude(const path &fp, std::vector<string> *pLibDefFiles)
{
    for (int i = 0; i < pLibDefFiles->size(); ++i)
    {
        if (fp.string().c_str() == (*pLibDefFiles)[i])
        {
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaa70
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x80eb
movq -0x10(%rbp), %rdi
callq 0xa5b0
movq %rax, %rdi
callq 0x6170
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xaac0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xaa90
testb $0x1, %al
jne 0x80d8
jmp 0x80de
movb $0x1, -0x1(%rbp)
jmp 0x80ef
jmp 0x80e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8087
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/examples/user-types-ex02.cxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, B*, void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(B*&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(B*& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<Y>(i, e, cx)) // consume any white-spaces
                        return false;
                    if (cio::peek(i, e) == *Y::id::nil) // check/read null
                        return read_value<Y>(t, i, e, cx);
                    B_union p; // the union type that represents a B*
                        if (read_value<Y>(p, i, e, cx)) { // try reading it
                            if (p.d1) // let d1 != 0 indicates D1
                                return (t = alc::make_in_context<D1>(cx, p.d1)); // create and assign D1
                            // create and assign D2
                            return (t = alc::make_in_context<D2>(cx, std::move(p.d2)));
                        }
                        return false;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4960
testb $0x1, %al
jne 0x4da9
movb $0x0, -0x1(%rbp)
jmp 0x4eb0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x34f0
movsbl %al, %eax
movsbl 0x7716(%rip), %ecx      # 0xc4d9
cmpl %ecx, %eax
jne 0x4de6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x4d00
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4eb0
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4ed0
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x4f00
movb %al, -0x61(%rbp)
jmp 0x4e0d
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x4e19
jmp 0x4e9c
cmpl $0x0, -0x50(%rbp)
je 0x4e69
movq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4f40
movq %rax, -0x78(%rbp)
jmp 0x4e32
movq -0x78(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x60(%rbp)
jmp 0x4ea7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5020
jmp 0x4ebe
movq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4fb0
movq %rax, -0x80(%rbp)
jmp 0x4e7c
movq -0x80(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x60(%rbp)
jmp 0x4ea7
movb $0x0, -0x1(%rbp)
movl $0x1, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5020
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2230
nopw (%rax,%rax)
// File: oknenavin[P]cxon/examples/user-types-ex02.cxx
// Function: bool cxon::write<cxon::JSON<cxon::json::format_traits>, B*, void>::value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, B const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(O& o, const B* t, Cx& cx) {
                    if (!t) // check/write null
                            return write_value<Y>(o, nullptr, cx);
                    // cast and write the runtime type
                    switch (t->type) {
                        case B::D1:
                            return write_value<Y>(o, static_cast<const D1*>(t), cx);
                        case B::D2:
                            return write_value<Y>(o, static_cast<const D2*>(t), cx);
                    }
                    return false;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9f4b
movq -0x10(%rbp), %rdi
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0x9fc0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9fa9
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x9f65
jmp 0x9f5b
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x9f85
jmp 0x9fa5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0x9ff0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9fa9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0xa020
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9fa9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/lambda.cc
// Function: fcn1()
void fcn1()
{
    size_t v1 = 42;  // local variable
    // copies v1 into the callable object named f
    auto f = [v1] { return v1; };
    v1 = 0;
    auto j = f(); // j is 42; f stored a copy of v1 when we created it
    cout << j << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x2a, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1220
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq 0x2de0(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
movq 0x2dc1(%rip), %rsi      # 0x3fc8
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/lambda.cc
// Function: fcn2()
void fcn2()
{
    size_t v1 = 42;  // local variable
    // the object f2 contains a reference to v1
    auto f2 = [&v1] { return v1; };
    v1 = 0;
    auto j = f2(); // j is 0; f2 refers to v1; it doesn't store it
    cout << j << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x2a, -0x8(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x12a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq 0x2d60(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
movq 0x2d41(%rip), %rsi      # 0x3fc8
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/lambda.cc
// Function: fcn3()
void fcn3()
{
    size_t v1 = 42;  // local variable
    // error: cannot assign to a variable captured by copy in a non-mutable lambda
    // auto f = [v1] () { return ++v1; };
    // f can change the value of the variables it captures
    auto f = [v1] () mutable { return ++v1; };
    v1 = 0;
    auto j = f(); // j is 43
    auto k = f(); // k is 44
    cout << v1 << endl;
    cout << j << endl;
    cout << k << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x2a, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1360
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1360
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq 0x2cd3(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
movq 0x2cb4(%rip), %rsi      # 0x3fc8
callq 0x1060
movq -0x18(%rbp), %rsi
movq 0x2cb4(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
movq 0x2c95(%rip), %rsi      # 0x3fc8
callq 0x1060
movq -0x20(%rbp), %rsi
movq 0x2c95(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
movq 0x2c76(%rip), %rsi      # 0x3fc8
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/lambda.cc
// Function: fcn4()
void fcn4()
{
    size_t v1 = 42;  // local variable
    // v1 is a reference to a nonconst variable
    // we can change that variable through the reference inside f2
    auto f2 = [&v1]() { return ++v1; };
    v1 = 0;
    auto j = f2(); // j is 1
    cout << j << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x2a, -0x8(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x13e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq 0x2c20(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
movq 0x2c01(%rip), %rsi      # 0x3fc8
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/lambda.cc
// Function: fcn5()
void fcn5()
{
    size_t v1 = 42;
    // p is a const pointer to v1
    size_t* const p = &v1;
    // increments v1, the objet to which p points
    auto f = [p]() { return ++*p; };
    auto j = f();  // returns incremented value of *p
    cout << v1 << " " << j << endl; // prints 43 43
    v1 = 0;
    j = f();       // returns incremented value of *p
    cout << v1 << " " << j << endl; // prints 1 1
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x2a, -0x8(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x14c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq 0x2ba0(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
leaq 0xbbd(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x1030
movq %rax, %rdi
movq 0x2b66(%rip), %rsi      # 0x3fc8
callq 0x1060
movq $0x0, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x14c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq 0x2b51(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
leaq 0xb6e(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x1030
movq %rax, %rdi
movq 0x2b17(%rip), %rsi      # 0x3fc8
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/lambda.cc
// Function: main
int main()
{
    fcn1();
    fcn2();
    fcn3();
    fcn4();
    fcn5();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x11c0
callq 0x1240
callq 0x12c0
callq 0x1380
callq 0x1400
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: PrzemekWirkus[P]functional-workshop/src/examples.cpp
// Function: void bubble_sort<int, std::less<int>>(int*, int, std::less<int> const&)
void bubble_sort(T* _array, int Count, const CompareType& Compare) {
	for(int i = 0; i < Count; ++i) {
		for(int j = i + 1; j < Count; ++j) {
            // functor call
            if (Compare(_array[i], _array[j])) {
                // exchange of two elements
                const T temp = _array[i];
                _array[i] = _array[j];
                _array[j] = temp;
            }
        }
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3cb3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3ca3
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rdx
movslq -0x20(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x3bd0
testb $0x1, %al
jne 0x3c64
jmp 0x3c96
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x3c98
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3c2f
jmp 0x3ca5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3c1a
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: akw0088[P]openssl/aes_dec.cpp
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 3)
	{
		printf("Usage:\taes_dec 256bit_key 128bit_iv plaintext\r\n");
		printf("Example:\taes_dec 01234567890123456789012345678901 0123456789012345 file.enc\r\n");
		return -1;
	}

	/* A 256 bit key */
	unsigned char *key = (unsigned char *)argv[1];

	/* A 128 bit IV */
	unsigned char *iv = (unsigned char *)argv[2];

	/* Message to be encrypted */
	char *filename = (char *)argv[3];
	unsigned int size = 0;
	unsigned char *ciphertext = (unsigned char *)get_file(filename, &size);

	/* Buffer for the decrypted text */
	unsigned char *decryptedtext = (unsigned char *)malloc(size);
	if (decryptedtext == NULL)
	{
		perror("malloc failed");
		return -1;
	}

	int decryptedtext_len, ciphertext_len = size;

	printf("Ciphertext is:\n");
	BIO_dump_fp (stdout, (const char *)ciphertext, ciphertext_len);

	/* Decrypt the ciphertext */
	decryptedtext_len = decrypt(ciphertext, ciphertext_len, key, iv, decryptedtext);

	/* Add a NULL terminator. We are expecting printable text */
	decryptedtext[decryptedtext_len] = '\0';

	/* Show the decrypted text */
	printf("Decrypted text is:\n");
	printf("%s\n", decryptedtext);
	
	write_file((char *)"file.txt", (char *)decryptedtext, decryptedtext_len);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x1484
leaq 0xbe4(%rip), %rdi       # 0x2047
movb $0x0, %al
callq 0x1050
leaq 0xc06(%rip), %rdi       # 0x2077
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1578
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x12a0
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %edi
callq 0x1160
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x14ed
leaq 0xbe9(%rip), %rdi       # 0x20c5
callq 0x1100
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1578
movl -0x2c(%rbp), %eax
movl %eax, -0x48(%rbp)
leaq 0xbd9(%rip), %rdi       # 0x20d3
movb $0x0, %al
callq 0x1050
movq 0x2ac0(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
movl -0x48(%rbp), %edx
callq 0x10c0
movq -0x38(%rbp), %rdi
movl -0x48(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %r8
callq 0x1590
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movb $0x0, (%rax,%rcx)
leaq 0xb9e(%rip), %rdi       # 0x20e3
movb $0x0, %al
callq 0x1050
movq -0x40(%rbp), %rsi
leaq 0xba0(%rip), %rdi       # 0x20f7
movb $0x0, %al
callq 0x1050
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %edx
leaq 0xb8f(%rip), %rdi       # 0x20fb
callq 0x13a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akw0088[P]openssl/aes_dec.cpp
// Function: decrypt(unsigned char*, int, unsigned char*, unsigned char*, unsigned char*)
int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key,
			unsigned char *iv, unsigned char *plaintext)
{
	EVP_CIPHER_CTX *ctx;

	int len;

	int plaintext_len;

	/* Create and initialise the context */
	if(!(ctx = EVP_CIPHER_CTX_new()))
		handleErrors();

	/*
	 * Initialise the decryption operation. IMPORTANT - ensure you use a key
	 * and IV size appropriate for your cipher
	 * In this example we are using 256 bit AES (i.e. a 256 bit key). The
	 * IV size for *most* modes is the same as the block size. For AES this
	 * is 128 bits
	 */
	if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
		handleErrors();

	/*
	 * Provide the message to be decrypted, and obtain the plaintext output.
	 * EVP_DecryptUpdate can be called multiple times if necessary.
	 */
	if(1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len))
		handleErrors();
	plaintext_len = len;

	/*
	 * Finalise the decryption. Further plaintext bytes may be written at
	 * this stage.
	 */
	if(1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len))
		handleErrors();
	plaintext_len += len;

	/* Clean up */
	EVP_CIPHER_CTX_free(ctx);

	return plaintext_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
callq 0x10f0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x15bf
callq 0x1670
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x10e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x1070
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x15f4
callq 0x1670
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %r8d
leaq -0x34(%rbp), %rdx
callq 0x10d0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x161d
callq 0x1670
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x34(%rbp), %rax
addq %rax, %rsi
leaq -0x34(%rbp), %rdx
callq 0x1080
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x164b
callq 0x1670
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1120
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akw0088[P]openssl/aes_dec.cpp
// Function: encrypt(unsigned char*, int, unsigned char*, unsigned char*, unsigned char*)
int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
			unsigned char *iv, unsigned char *ciphertext)
{
	EVP_CIPHER_CTX *ctx;

	int len;

	int ciphertext_len;

	/* Create and initialise the context */
	if(!(ctx = EVP_CIPHER_CTX_new()))
		handleErrors();

	/*
	 * Initialise the encryption operation. IMPORTANT - ensure you use a key
	 * and IV size appropriate for your cipher
	 * In this example we are using 256 bit AES (i.e. a 256 bit key). The
	 * IV size for *most* modes is the same as the block size. For AES this
	 * is 128 bits
	 */
	if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
		handleErrors();

	/*
	 * Provide the message to be encrypted, and obtain the encrypted output.
	 * EVP_EncryptUpdate can be called multiple times if necessary
	 */
	if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
		handleErrors();
	ciphertext_len = len;

	/*
	 * Finalise the encryption. Further ciphertext bytes may be written at
	 * this stage.
	 */
	if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len))
		handleErrors();
	ciphertext_len += len;

	/* Clean up */
	EVP_CIPHER_CTX_free(ctx);

	return ciphertext_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
callq 0x10f0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x16bf
callq 0x1670
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x10e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x10b0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x16f4
callq 0x1670
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %r8d
leaq -0x34(%rbp), %rdx
callq 0x1060
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x171d
callq 0x1670
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x34(%rbp), %rax
addq %rax, %rsi
leaq -0x34(%rbp), %rdx
callq 0x1180
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x174b
callq 0x1670
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1120
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: Air::altitude_with_variation(double, double)
Air Air::altitude_with_variation(double altitude, double input_percent){
    // Pseudo constructor.
    // Enter altitude and variation ratio air density with altitude to calculate air density
    Air air = Air::altitude(altitude);
    double coef = Air::coef_density_variance(altitude, input_percent);
    air.density = air.density * (1.0 + coef);
    return air;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x6db0
movq -0x38(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x7210
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movsd 0x118(%rdi), %xmm0
movsd 0x4ae4d(%rip), %xmm1    # 0x52040
addsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x118(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: Air::altitude_with_variation_table(double, Eigen::Matrix<double, -1, -1, 0, -1, -1>)
Air Air::altitude_with_variation_table(double altitude, MatrixXd variation_table){
    // Pseudo constructor.
    // Enter altitude and variation ratio air density table to calculate air density
    Air air = Air::altitude(altitude);
    double coef = Air::coef_density_variance_table(altitude, variation_table);
    air.density = air.density * (1.0 + coef);
    return air;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x70(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x68(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x6db0
movq -0x70(%rbp), %rsi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x8170
movq -0x68(%rbp), %rdi
movsd -0x60(%rbp), %xmm0
movq -0x58(%rbp), %rsi
callq 0x7910
movsd %xmm0, -0x50(%rbp)
jmp 0x78ad
leaq -0x38(%rbp), %rdi
callq 0x8220
movsd -0x50(%rbp), %xmm0
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movsd 0x118(%rcx), %xmm0
movsd 0x4a768(%rip), %xmm1    # 0x52040
addsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x118(%rcx)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8220
movq -0x40(%rbp), %rdi
callq 0x67a0
// File: istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: Air::coef_density_variance_table(double, Eigen::Matrix<double, -1, -1, 0, -1, -1>)
double Air::coef_density_variance_table(double altitude, MatrixXd variation_table){
    // variation table : [altitude[m], air density variation[percent]
    vector<double> altitude_ref;
    vector<double> variation_ref;
    int len = variation_table.rows();

    altitude_ref.resize(len);
    variation_ref.resize(len);

    for(int i=0; i<len; i++){
        altitude_ref[i] = variation_table(i, 0);
        variation_ref[i] = variation_table(i, 1);
    }
    
    double percent_of_density_with_alt = linear_interp1_from_y(altitude, variation_ref, altitude_ref);

    return percent_of_density_with_alt / 100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8470
leaq -0x48(%rbp), %rdi
callq 0x8470
movq -0xa8(%rbp), %rdi
callq 0x8490
movq %rax, -0xa0(%rbp)
jmp 0x7956
movq -0xa0(%rbp), %rax
movl %eax, -0x4c(%rbp)
movslq -0x4c(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x84b0
jmp 0x796f
movslq -0x4c(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x84b0
jmp 0x797e
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0x7a43
movq -0xa8(%rbp), %rdi
movslq -0x60(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8540
movq %rax, -0xb0(%rbp)
jmp 0x79ae
movq -0xb0(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0xc0(%rbp)
movslq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x8600
movsd -0xc0(%rbp), %xmm0
movq -0xa8(%rbp), %rdi
movsd %xmm0, (%rax)
movslq -0x60(%rbp), %rsi
movl $0x1, %edx
callq 0x8540
movq %rax, -0xb8(%rbp)
jmp 0x79f8
movq -0xb8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0xc8(%rbp)
movslq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x8600
movsd -0xc8(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x7985
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7b20
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8300
jmp 0x7a5f
leaq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8300
jmp 0x7a71
movsd -0xd0(%rbp), %xmm0
leaq -0x80(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x7b40
movsd %xmm0, -0xd8(%rbp)
jmp 0x7a93
leaq -0x98(%rbp), %rdi
callq 0x83f0
leaq -0x80(%rbp), %rdi
callq 0x83f0
movsd -0xd8(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
movsd 0x4a586(%rip), %xmm1    # 0x52048
divsd %xmm1, %xmm0
movsd %xmm0, -0xe0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x83f0
leaq -0x30(%rbp), %rdi
callq 0x83f0
movsd -0xe0(%rbp), %xmm0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7b17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x83f0
leaq -0x80(%rbp), %rdi
callq 0x83f0
leaq -0x48(%rbp), %rdi
callq 0x83f0
leaq -0x30(%rbp), %rdi
callq 0x83f0
movq -0x58(%rbp), %rdi
callq 0x67a0
nopl (%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/util/Memory.h
// Function: double* Eigen::internal::conditional_aligned_new_auto<double, true>(unsigned long)
inline T* conditional_aligned_new_auto(size_t size)
{
  if(size==0)
    return 0; // short-cut. Also fixes Bug 884
  check_size_for_overflow<T>(size);
  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
  if(NumTraits<T>::RequireInitialization)
    construct_elements_of_array(result, size);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x894d
movq $0x0, -0x10(%rbp)
jmp 0x8983
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, -0x8(%rbp)
jbe 0x896a
callq 0x89b0
movq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x8990
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, -1, 0>::resize(long, long, long)
void resize(DenseIndex size, DenseIndex nbRows, DenseIndex nbCols)
    {
      if(size != m_rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
        if (size)
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
      }
      m_rows = nbRows;
      m_cols = nbCols;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rdx), %rcx
imulq 0x10(%rdx), %rcx
cmpq %rcx, %rax
je 0x8f20
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
imulq 0x10(%rax), %rsi
callq 0x86e0
cmpq $0x0, -0x10(%rbp)
je 0x8f13
movq -0x10(%rbp), %rdi
callq 0x8930
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x8f1e
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
jmp 0x8f20
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::value::~value()
inline value::~value() {
    switch (type_) {
#define DEINIT(p) case p##type: delete u_.p; break
      DEINIT(string_);
      DEINIT(array_);
      DEINIT(object_);
#undef DEINIT
    default: break;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x3, %eax
je 0xb6f7
jmp 0xb6e0
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0xb722
jmp 0xb6ea
movl -0xc(%rbp), %eax
subl $0x5, %eax
je 0xb74d
jmp 0xb778
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xb720
movq -0x20(%rbp), %rdi
callq 0x68a8
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x6490
jmp 0xb77a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xb74b
movq -0x28(%rbp), %rdi
callq 0xb780
movq -0x28(%rbp), %rdi
movl $0x18, %esi
callq 0x6490
jmp 0xb77a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xb776
movq -0x30(%rbp), %rdi
callq 0xb400
movq -0x30(%rbp), %rdi
movl $0x30, %esi
callq 0x6490
jmp 0xb77a
jmp 0xb77a
addq $0x30, %rsp
popq %rbp
retq
// File: istellartech[P]OpenTsiolkovsky/src/rocket.cpp
// Function: RocketStage::quatNAVI2BODY(double)
Quaterniond RocketStage::quatNAVI2BODY(double t){
    Quaterniond quatNAVI2BODY_, quat_drift_NAVI2BODY_;

    double gyro_bias_abs = this->gyro_bias.norm();
    if (gyro_bias_abs != 0.0) {
        Vector3d gyro_bias_direction = this->gyro_bias / gyro_bias_abs;
        quat_drift_NAVI2BODY_ = Quaterniond(AngleAxisd(gyro_bias_abs * t, gyro_bias_direction));
    } else {
        quat_drift_NAVI2BODY_ = Quaterniond::Identity();
    }

    quatNAVI2BODY_ = this->quat_offset_NAVI2BODY * quat_drift_NAVI2BODY_;
    return quatNAVI2BODY_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x118(%rbp)
movq %rdi, %rax
movq %rax, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x108(%rbp)
callq 0x1dbc0
leaq -0x40(%rbp), %rdi
callq 0x1dbc0
movq -0x108(%rbp), %rdi
addq $0x630, %rdi            # imm = 0x630
callq 0x205d0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1b91c
jp 0x1b91c
jmp 0x1b992
movq -0x108(%rbp), %rsi
addq $0x630, %rsi            # imm = 0x630
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x205f0
leaq -0x60(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x20650
movsd -0x48(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x206d0
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x20710
leaq -0x40(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1e1b0
jmp 0x1b9ae
leaq -0xe0(%rbp), %rdi
callq 0x20740
leaq -0x40(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1e1b0
movq -0x108(%rbp), %rsi
addq $0x610, %rsi            # imm = 0x610
leaq -0x100(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x207a0
movq -0x118(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x1e1b0
movq -0x110(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: istellartech[P]OpenTsiolkovsky/src/rocket.cpp
// Function: RocketStage::progress(double)
void RocketStage::progress(double time_now){
    double time_total = calc_end_time;
    cout << fixed << setprecision(0);
    cout << time_now << "sec / " << time_total << "sec\t@Stage " << num_stage << "\r" << flush;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd 0x260(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0x5d593(%rip), %rdi     # 0x78fb0
leaq 0x45dc(%rip), %rsi      # 0x20000
callq 0x6190
movq %rax, -0x30(%rbp)
xorl %edi, %edi
callq 0x20030
movq -0x30(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x66a0
movsd -0x10(%rbp), %xmm0
movq 0x5d561(%rip), %rdi     # 0x78fb0
callq 0x6830
movq %rax, %rdi
leaq 0x38239(%rip), %rsi     # 0x53c97
callq 0x6460
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x6830
movq %rax, %rdi
leaq 0x38224(%rip), %rsi     # 0x53c9e
callq 0x6460
movq %rax, %rdi
movq -0x28(%rbp), %rax
movl 0x250(%rax), %esi
callq 0x6780
movq %rax, %rdi
leaq 0x380b9(%rip), %rsi     # 0x53b54
callq 0x6460
movq %rax, %rdi
movq 0x5d516(%rip), %rsi     # 0x78fc0
callq 0x64c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: operator>>(std::istream&, picojson::value&)
inline std::istream& operator>>(std::istream& is, picojson::value& x)
{
  picojson::set_last_error(std::string());
  std::string err = picojson::parse(x, is);
  if (! err.empty()) {
    picojson::set_last_error(err);
    is.setstate(std::ios::failbit);
  }
  return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x6610
movq -0x68(%rbp), %rdi
callq 0x21280
jmp 0x1d718
leaq -0x30(%rbp), %rdi
callq 0x68a8
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x212b0
leaq -0x60(%rbp), %rdi
callq 0x6720
testb $0x1, %al
jne 0x1d794
leaq -0x60(%rbp), %rdi
callq 0x21280
jmp 0x1d74a
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
movl $0x4, %esi
callq 0x62e0
jmp 0x1d764
jmp 0x1d794
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x68a8
jmp 0x1d7af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x68a8
jmp 0x1d7af
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x68a8
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x67a0
nopl (%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/DenseCoeffsBase.h
// Function: Eigen::DenseCoeffsBase<Eigen::Matrix<double, 3, 1, 0, 3, 1>, 1>::operator[](long)
EIGEN_STRONG_INLINE Scalar&
    operator[](Index index)
    {
      #ifndef EIGEN2_SUPPORT
      EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
                          THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
      #endif
      eigen_assert(index >= 0 && index < size());
      return derived().coeffRef(index);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
jl 0x1de85
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x28b50
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1de8e
jmp 0x1de90
jmp 0x1deaf
leaq 0x36a0f(%rip), %rdi     # 0x548a6
leaq 0x348d3(%rip), %rsi     # 0x52771
movl $0x17a, %edx            # imm = 0x17A
leaq 0x36a19(%rip), %rcx     # 0x548c3
callq 0x62f0
movq -0x20(%rbp), %rdi
callq 0x26d60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x27330
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/rocket.hpp
// Function: CsvObserver::CsvObserver(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
CsvObserver(const std::string& FileName, bool isAddition = false){
        if (isAddition == false){ // 追加書き込みモードかどうか
            fout.open(FileName, std::ios_base::out);
            fout << header << std::endl;
        } else {
            fout.open(FileName, std::ios_base::out | std::ios_base::app); // 追加書き込みモード
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x25f00
movq -0x38(%rbp), %rdi
leaq 0x592b1(%rip), %rax     # 0x785d0
movq %rax, (%rdi)
addq $0xec0, %rdi            # imm = 0xEC0
movq %rdi, -0x30(%rbp)
callq 0x6740
jmp 0x1f334
movq -0x38(%rbp), %rax
addq $0x10c0, %rax           # imm = 0x10C0
movq %rax, -0x48(%rbp)
leaq -0x25(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x67b0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x34aea(%rip), %rsi     # 0x53e48
callq 0xac00
jmp 0x1f365
leaq -0x25(%rbp), %rdi
callq 0x64e0
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1f40a
movq -0x38(%rbp), %rdi
addq $0xec0, %rdi            # imm = 0xEC0
movq -0x10(%rbp), %rsi
movl $0x10, %edx
callq 0x6240
jmp 0x1f39a
movq -0x38(%rbp), %rsi
movq %rsi, %rdi
addq $0xec0, %rdi            # imm = 0xEC0
addq $0x10c0, %rsi           # imm = 0x10C0
callq 0x6410
movq %rax, -0x50(%rbp)
jmp 0x1f3ba
movq -0x50(%rbp), %rdi
movq 0x59b93(%rip), %rsi     # 0x78f58
callq 0x64c0
jmp 0x1f3cc
jmp 0x1f448
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1f457
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x64e0
jmp 0x1f44e
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x68a8
jmp 0x1f44e
movq -0x38(%rbp), %rax
addq $0xec0, %rax            # imm = 0xEC0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x10, %edi
movl $0x1, %esi
callq 0x26890
movl %eax, -0x54(%rbp)
jmp 0x1f434
movl -0x54(%rbp), %edx
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x6240
jmp 0x1f446
jmp 0x1f448
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6650
movq -0x38(%rbp), %rdi
callq 0xb260
movq -0x20(%rbp), %rdi
callq 0x67a0
nopl (%rax)