LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: drummyfish[P]flowchart/src/bitmap_image.hpp
// Function: bitmap_image::set_pixel(unsigned int, unsigned int, unsigned char, unsigned char, unsigned char)
inline void set_pixel(const unsigned int x, const unsigned int y,
                         const unsigned char red,
                         const unsigned char green,
                         const unsigned char blue)
   {
      const unsigned int y_offset = y * row_increment_;
      const unsigned int x_offset = x * bytes_per_pixel_;
      data_[y_offset + x_offset + 0] = blue;
      data_[y_offset + x_offset + 1] = green;
      data_[y_offset + x_offset + 2] = red;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %r8d, -0x2c(%rbp)
movl %ecx, %eax
movl -0x2c(%rbp), %ecx
movl %eax, -0x28(%rbp)
movl %edx, %eax
movl -0x28(%rbp), %edx
movl %eax, -0x24(%rbp)
movl %esi, %eax
movl -0x24(%rbp), %esi
movl %eax, -0x20(%rbp)
movq %rdi, %r8
movl -0x20(%rbp), %edi
movb %r9b, %al
movq %r8, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movb %cl, -0x12(%rbp)
movb %al, -0x13(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
imull 0x38(%rax), %ecx
movl %ecx, -0x18(%rbp)
movl -0xc(%rbp), %ecx
imull 0x28(%rax), %ecx
movl %ecx, -0x1c(%rbp)
movb -0x13(%rbp), %sil
movq 0x20(%rax), %rcx
movl -0x18(%rbp), %edx
addl -0x1c(%rbp), %edx
addl $0x0, %edx
movl %edx, %edx
movb %sil, (%rcx,%rdx)
movb -0x12(%rbp), %sil
movq 0x20(%rax), %rcx
movl -0x18(%rbp), %edx
addl -0x1c(%rbp), %edx
addl $0x1, %edx
movl %edx, %edx
movb %sil, (%rcx,%rdx)
movb -0x11(%rbp), %dl
movq 0x20(%rax), %rax
movl -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/bitmap_image.hpp
// Function: bitmap_image::get_pixel(unsigned int, unsigned int, unsigned char&, unsigned char&, unsigned char&)
inline void get_pixel(const unsigned int x, const unsigned int y,
                         unsigned char& red,
                         unsigned char& green,
                         unsigned char& blue)
   {
      const unsigned int y_offset = y * row_increment_;
      const unsigned int x_offset = x * bytes_per_pixel_;
      blue  = data_[y_offset + x_offset + 0];
      green = data_[y_offset + x_offset + 1];
      red   = data_[y_offset + x_offset + 2];
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
imull 0x38(%rax), %ecx
movl %ecx, -0x2c(%rbp)
movl -0xc(%rbp), %ecx
imull 0x28(%rax), %ecx
movl %ecx, -0x30(%rbp)
movq 0x20(%rax), %rcx
movl -0x2c(%rbp), %edx
addl -0x30(%rbp), %edx
addl $0x0, %edx
movl %edx, %edx
movb (%rcx,%rdx), %dl
movq -0x28(%rbp), %rcx
movb %dl, (%rcx)
movq 0x20(%rax), %rcx
movl -0x2c(%rbp), %edx
addl -0x30(%rbp), %edx
addl $0x1, %edx
movl %edx, %edx
movb (%rcx,%rdx), %dl
movq -0x20(%rbp), %rcx
movb %dl, (%rcx)
movq 0x20(%rax), %rax
movl -0x2c(%rbp), %ecx
addl -0x30(%rbp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/bitmap_image.hpp
// Function: bitmap_image::read_bfh(std::basic_ifstream<char, std::char_traits<char>>&, bitmap_image::bitmap_file_header&)
inline void read_bfh(std::ifstream& stream, bitmap_file_header& bfh)
   {
      read_from_stream(stream,bfh.type);
      read_from_stream(stream,bfh.size);
      read_from_stream(stream,bfh.reserved1);
      read_from_stream(stream,bfh.reserved2);
      read_from_stream(stream,bfh.off_bits);

      if (big_endian())
      {
         bfh.type = flip(bfh.type);
         bfh.size = flip(bfh.size);
         bfh.reserved1 = flip(bfh.reserved1);
         bfh.reserved2 = flip(bfh.reserved2);
         bfh.off_bits = flip(bfh.off_bits);
      }
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16df0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x4, %rdx
callq 0x16e20
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
callq 0x16df0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0xa, %rdx
callq 0x16df0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0xc, %rdx
callq 0x16e20
movq -0x20(%rbp), %rdi
callq 0x16e50
testb $0x1, %al
jne 0x16a8f
jmp 0x16b12
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16e80
movq -0x20(%rbp), %rdi
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
callq 0x16eb0
movq -0x20(%rbp), %rdi
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x16e80
movq -0x20(%rbp), %rdi
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x18(%rbp), %rsi
addq $0xa, %rsi
callq 0x16e80
movq -0x20(%rbp), %rdi
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
callq 0x16eb0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: drummyfish[P]flowchart/src/bitmap_image.hpp
// Function: bitmap_image::create_bitmap()
void create_bitmap()
   {
      length_ = width_ * height_ * bytes_per_pixel_;
      row_increment_ = width_ * bytes_per_pixel_;
      if (0 != data_)
      {
         delete[] data_;
      }
      data_ = new unsigned char[length_];
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x30(%rcx), %eax
imull 0x34(%rcx), %eax
imull 0x28(%rcx), %eax
movl %eax, 0x2c(%rcx)
movl 0x30(%rcx), %eax
imull 0x28(%rcx), %eax
movl %eax, 0x38(%rcx)
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
je 0x16da1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x16d9f
movq -0x18(%rbp), %rdi
callq 0x3320
jmp 0x16da1
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, %edi
callq 0x3040
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: drummyfish[P]flowchart/src/bitmap_image.hpp
// Function: bitmap_image::flip(unsigned int const&)
inline unsigned int flip(const unsigned int& v)
   {
      return (((v & 0xFF000000) >> 0x18) |
              ((v & 0x000000FF) << 0x18) |
              ((v & 0x00FF0000) >> 0x08) |
              ((v & 0x0000FF00) << 0x08));
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff000000, %eax       # imm = 0xFF000000
shrl $0x18, %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
andl $0xff, %ecx
shll $0x18, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
shrl $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
shll $0x8, %ecx
orl %ecx, %eax
popq %rbp
retq
nop
// File: drummyfish[P]flowchart/src/bitmap_image.hpp
// Function: bitmap_image::write_bfh(std::basic_ofstream<char, std::char_traits<char>>&, bitmap_image::bitmap_file_header const&)
inline void write_bfh(std::ofstream& stream, const bitmap_file_header& bfh)
   {
      if (big_endian())
      {
         write_to_stream(stream,flip(bfh.type));
         write_to_stream(stream,flip(bfh.size));
         write_to_stream(stream,flip(bfh.reserved1));
         write_to_stream(stream,flip(bfh.reserved2));
         write_to_stream(stream,flip(bfh.off_bits));
      }
      else
      {
         write_to_stream(stream,bfh.type);
         write_to_stream(stream,bfh.size);
         write_to_stream(stream,bfh.reserved1);
         write_to_stream(stream,bfh.reserved2);
         write_to_stream(stream,bfh.off_bits);
      }
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x16e50
testb $0x1, %al
jne 0x16f4a
jmp 0x1702c
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rsi
callq 0x16e80
movq -0x58(%rbp), %rsi
movq -0x30(%rbp), %rdi
movw %ax, -0x1a(%rbp)
leaq -0x1a(%rbp), %rdx
callq 0x173d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
callq 0x16eb0
movq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdi
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rdx
callq 0x17400
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x16e80
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdi
movw %ax, -0x22(%rbp)
leaq -0x22(%rbp), %rdx
callq 0x173d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
addq $0xa, %rsi
callq 0x16e80
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdi
movw %ax, -0x24(%rbp)
leaq -0x24(%rbp), %rdx
callq 0x173d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
callq 0x16eb0
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x17400
jmp 0x17091
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x173d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x4, %rdx
callq 0x17400
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
callq 0x173d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0xa, %rdx
callq 0x173d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0xc, %rdx
callq 0x17400
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: drummyfish[P]flowchart/src/program.cpp
// Function: program::char_from_image_position(image*, coord_2d)
int program::char_from_image_position(image *img, coord_2d c)
  {
    unsigned int i, j, k, x, y;
    unsigned char r,g,b,r2,g2,b2;
    bool matches;

    for (k = 0; k < 256; k++)
      {
        x = (k % FONT_ROW_SYMBOLS) * FONT_WIDTH;   // character coordinates in the font mask
        y = (k / FONT_ROW_SYMBOLS) * FONT_HEIGHT;

        matches = true;

        for (j = 0; j < FONT_HEIGHT; j++)
          {
            for (i = 0; i < FONT_WIDTH; i++)
              {
                img->get_pixel(c.x + i,c.y + j,r,g,b);
                this->font_mask.get_pixel(x + i,y + j,r2,g2,b2);

                if ((is_black(r,g,b)) != (is_black(r2,g2,b2)))
                  matches = false;
              }
          }

        if (matches)
          return k;
      }

    return -1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x100, -0x2c(%rbp)     # imm = 0x100
jae 0x1864f
movl -0x2c(%rbp), %eax
andl $0x1f, %eax
imull $0x7, %eax, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
shrl $0x5, %eax
shll $0x3, %eax
movl %eax, -0x34(%rbp)
movb $0x1, -0x3b(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x8, -0x28(%rbp)
jae 0x18631
movl $0x0, -0x24(%rbp)
cmpl $0x7, -0x24(%rbp)
jae 0x18621
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
addl -0x24(%rbp), %esi
movl -0x8(%rbp), %edx
addl -0x28(%rbp), %edx
leaq -0x35(%rbp), %rcx
leaq -0x36(%rbp), %r8
leaq -0x37(%rbp), %r9
callq 0x15f80
movq -0x48(%rbp), %rdi
movl -0x30(%rbp), %esi
addl -0x24(%rbp), %esi
movl -0x34(%rbp), %edx
addl -0x28(%rbp), %edx
leaq -0x38(%rbp), %rcx
leaq -0x39(%rbp), %r8
leaq -0x3a(%rbp), %r9
callq 0x15f80
movzbl -0x35(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
jne 0x185c9
movzbl -0x36(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
jne 0x185c9
movzbl -0x37(%rbp), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x50(%rbp)
movzbl -0x38(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x4a(%rbp)
jne 0x185fd
movzbl -0x39(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x4a(%rbp)
jne 0x185fd
movzbl -0x3a(%rbp), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x4a(%rbp)
movl -0x50(%rbp), %eax
movb -0x4a(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x18611
movb $0x0, -0x3b(%rbp)
jmp 0x18613
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x18554
jmp 0x18623
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x18543
testb $0x1, -0x3b(%rbp)
je 0x1863f
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x18656
jmp 0x18641
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x18513
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: drummyfish[P]flowchart/src/program.cpp
// Function: program::string_from_image_position[abi:cxx11](image*, coord_2d, unsigned int, bool&)
string program::string_from_image_position(image *img, coord_2d c, unsigned int max_x, bool &success)
  {
    int character;
    string result;
    success = true;

    result = "";

    while (c.x <= max_x)
      {
        character = this->char_from_image_position(img,c);

        if (character < 0)    // error
          {
            success = false;
            result = "";
            return result;
          }

        result += (unsigned char) character;
        c.x += (FONT_WIDTH + 1);   // move to the next character
      }

    result = trim(result);

    if (result.length() == 0)
      success = false;

    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movb $0x0, -0x35(%rbp)
callq 0x3380
movq -0xa0(%rbp), %rdi
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
leaq 0x6da3(%rip), %rsi      # 0x1f460
callq 0x3370
jmp 0x186c4
jmp 0x186c6
movl -0x10(%rbp), %eax
cmpl -0x24(%rbp), %eax
ja 0x18762
movq -0xa8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdx
callq 0x184f0
movl %eax, -0xb4(%rbp)
jmp 0x186f6
movl -0xb4(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x18742
movq -0xa0(%rbp), %rdi
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
leaq 0x6d46(%rip), %rsi      # 0x1f460
callq 0x3370
jmp 0x18721
movb $0x1, -0x35(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x187ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x18810
movq -0xa0(%rbp), %rdi
movsbl -0x34(%rbp), %esi
callq 0x3170
jmp 0x18754
movl -0x10(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x10(%rbp)
jmp 0x186c6
movq -0xa0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x30f0
jmp 0x18777
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x1ca20
jmp 0x18789
movq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x32f0
leaq -0x78(%rbp), %rdi
callq 0x3160
leaq -0x98(%rbp), %rdi
callq 0x3160
movq -0xa0(%rbp), %rdi
callq 0x33e0
cmpq $0x0, %rax
jne 0x187e3
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
jmp 0x187e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3160
jmp 0x18810
movb $0x1, -0x35(%rbp)
movl $0x1, -0x54(%rbp)
testb $0x1, -0x35(%rbp)
jne 0x18800
movq -0xa0(%rbp), %rdi
callq 0x3160
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/general.cpp
// Function: saturate(int, int, int)
int saturate(int value, int min, int max)
  {
    if (value > max)
      return max;

    if (value < min)
      return min;

    return value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x1cadd
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1caf3
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1caed
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1caf3
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: margual56[P]Markdown-CLI/src/Component.cpp
// Function: Component::setText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Component::setText(std::string text){
    if(this->children.size() == 0)      // If no components were added before, 
        this->content = {text};         // just set the text (keep the reference NULL, the default)
    else                                // Otherwise,
        this->content = {text, this->children.back()}; // set the reference to the last component added
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x50, %rdi
callq 0x6150
cmpq $0x0, %rax
jne 0x5b8c
movq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x51d0
movq -0x68(%rbp), %rdi
movq $0x0, -0x18(%rbp)
addq $0x20, %rdi
leaq -0x38(%rbp), %rsi
callq 0x60d0
leaq -0x38(%rbp), %rdi
callq 0x60b0
jmp 0x5bc7
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x51d0
movq -0x68(%rbp), %rdi
addq $0x50, %rdi
callq 0x6180
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
addq $0x20, %rdi
leaq -0x60(%rbp), %rsi
callq 0x60d0
leaq -0x60(%rbp), %rdi
callq 0x60b0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/exponential.h
// Function: efgy::math::exponentiate::integral<efgy::math::numeric::fractional<long long>, 2l>::raise(efgy::math::numeric::fractional<long long> const&)
constexpr static Q raise(const Q &base) {
    return (exponent % 2 == 0)
               ? integral<Q, (exponent >> 1)>::raise(base * base)
               : (base *
                  integral<Q, ((exponent - 1) >> 1)>::raise(base * base));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x78d4
jmp 0x78fc
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29df0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x78a0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x793f
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29df0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x77e0
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x29df0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: KokiKishimoto[P]cp_decomposition/cp.cpp
// Function: ArgPos(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, char**)
int ArgPos(std::string str, int argc, char **argv) {
	int a;
	for (a = 1; a < argc; a++){
		if (str == argv[a]) {
			if (a == argc - 1) {
				std::cout << "Argument missing for" << str << std::endl;
				exit(1);
			}
			return a;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x369b
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3da0
testb $0x1, %al
jne 0x3641
jmp 0x368e
movl -0x24(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x3686
movq 0x14973(%rip), %rdi     # 0x17fc8
leaq 0xca0c(%rip), %rsi      # 0x10068
callq 0x3280
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq 0x14941(%rip), %rsi     # 0x17fb8
callq 0x32c0
movl $0x1, %edi
callq 0x3330
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a2
jmp 0x3690
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x361e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: KokiKishimoto[P]cp_decomposition/./data.hpp
// Function: Data::addEntity(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int addEntity(std::string entity) {
		if (entity_dict.find(entity) == entity_dict.end()) {
			int id = entity_counter;
			entity_dict[entity] = entity_counter;
			entity_dict_rev[entity_counter] = entity;
			++entity_counter;
			return id;
		} else {
			return entity_dict[entity];
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
callq 0x6590
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x65c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6560
testb $0x1, %al
jne 0x61ed
jmp 0x623c
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl (%rdi), %eax
movl %eax, -0x2c(%rbp)
movl (%rdi), %eax
movl %eax, -0x44(%rbp)
addq $0x8, %rdi
callq 0x65f0
movl -0x44(%rbp), %ecx
movq -0x38(%rbp), %rsi
movl %ecx, (%rax)
movq %rsi, %rdi
addq $0x68, %rdi
callq 0x66d0
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x3040
movq -0x38(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6252
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x65f0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: KokiKishimoto[P]cp_decomposition/./data.hpp
// Function: Data::addRelation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int addRelation(std::string relation) {
		if (relation_dict.find(relation) == relation_dict.end()) {
			int id = relation_counter;
			relation_dict[relation] = relation_counter;
			relation_dict_rev[relation_counter] = relation;
			++relation_counter;
			return id;
		} else {
			return relation_dict[relation];
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x38, %rdi
callq 0x6590
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x65c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6560
testb $0x1, %al
jne 0x62ad
jmp 0x6307
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl 0x4(%rdi), %eax
movl %eax, -0x2c(%rbp)
movl 0x4(%rdi), %eax
movl %eax, -0x44(%rbp)
addq $0x38, %rdi
callq 0x65f0
movl -0x44(%rbp), %ecx
movq -0x38(%rbp), %rsi
movl %ecx, (%rax)
movq %rsi, %rdi
addq $0x98, %rdi
addq $0x4, %rsi
callq 0x66d0
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x3040
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x631d
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x65f0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KokiKishimoto[P]cp_decomposition/cp.cpp
// Function: CP::initializeModel(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, int, std::uniform_real_distribution<double>&)
void initializeModel(std::vector< std::vector<double> >& Vec, const int counter, std::uniform_real_distribution<>& dist){
		for (int i = 0; i < counter; i++) {
			Vec[i].resize(vecDim);
			for (int j = 0; j < vecDim; j++) {
				Vec[i][j] = dist(rnd);
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9a1e
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xaa60
movq %rax, %rdi
movq -0x30(%rbp), %rax
movslq 0x200(%rax), %rsi
callq 0x9a80
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x200(%rcx), %eax
jge 0x9a0e
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x208, %rsi            # imm = 0x208
callq 0xaa80
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xaa60
movq %rax, %rdi
movslq -0x28(%rbp), %rsi
callq 0xaab0
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x99b9
jmp 0x9a10
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9986
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: KokiKishimoto[P]cp_decomposition/./random_sampler.hpp
// Function: RandomSampler::negativeSamplingSbj(Triple&, std::set<long long, std::less<long long>, std::allocator<long long>>&)
Triple negativeSamplingSbj(Triple& gold, std::set<long long>& triple_key_set) {
		for (;;) {
			int entity1 = getNextEnt();
			if (triple_key_set.find(key_gen.calcKey(entity1, gold.relation, gold.obj)) == triple_key_set.end()) 
			{
				triple.set(entity1, gold.relation, gold.obj);
				return triple;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xed00
movq -0x40(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x139c, %rdi           # imm = 0x139C
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
callq 0x64b0
movq -0x58(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xed60
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xeda0
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xed30
testb $0x1, %al
jne 0xc9ce
jmp 0xca1f
movq -0x40(%rbp), %rdi
addq $0x1388, %rdi           # imm = 0x1388
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
callq 0x8a20
movq -0x40(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq 0x1388(%rdx), %rsi
movq %rsi, (%rcx)
movq 0x1390(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movl 0x1398(%rdx), %edx
movl %edx, 0x10(%rcx)
addq $0x60, %rsp
popq %rbp
retq
jmp 0xc964
nopw %cs:(%rax,%rax)
nop
// File: KokiKishimoto[P]cp_decomposition/./random_sampler.hpp
// Function: RandomSampler::negativeSamplingObj(Triple&, std::set<long long, std::less<long long>, std::allocator<long long>>&)
Triple negativeSamplingObj(Triple& gold, std::set<long long>& triple_key_set) {
		for (;;) {
			int entity1 = getNextEnt();
			if (triple_key_set.find(key_gen.calcKey(gold.subj, gold.relation, entity1)) == triple_key_set.end()) 
			{
				triple.set(gold.subj, gold.relation, entity1);
				return triple;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xed00
movq -0x40(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x139c, %rdi           # imm = 0x139C
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movl -0x1c(%rbp), %ecx
callq 0x64b0
movq -0x58(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xed60
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xeda0
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xed30
testb $0x1, %al
jne 0xcabd
jmp 0xcb0d
movq -0x40(%rbp), %rdi
addq $0x1388, %rdi           # imm = 0x1388
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movl -0x1c(%rbp), %ecx
callq 0x8a20
movq -0x40(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq 0x1388(%rdx), %rsi
movq %rsi, (%rcx)
movq 0x1390(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movl 0x1398(%rdx), %edx
movl %edx, 0x10(%rcx)
addq $0x60, %rsp
popq %rbp
retq
jmp 0xca54
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: KokiKishimoto[P]cp_decomposition/./signal_operation.hpp
// Function: SignalOperation::product(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
std::vector<double> product(const std::vector<double>& a, const std::vector<double>& b, const std::vector<double>& c, std::vector<double>& out1, std::vector<double>& out2, std::vector<double>& out3) {
		for (int i = 0; i < a.size(); i++) {
			out1[i] = a[i] * b[i];
			out2[i] = b[i] * c[i];
			out3[i] = c[i] * a[i];
		}
		return out1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb090
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0xe5e1
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xe720
movsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xe720
movsd -0x80(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xaab0
movsd -0x78(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xe720
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xe720
movsd -0x70(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq 0x10(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xaab0
movsd -0x68(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xe720
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xe720
movsd -0x60(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq 0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xaab0
movsd -0x58(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xe4dd
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xe740
movq -0x40(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: KokiKishimoto[P]cp_decomposition/./signal_operation.hpp
// Function: SignalOperation::innerProduct(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double innerProduct(const std::vector<double>& a, const std::vector<double>& b) {
		double score = 0.0;
		for (int i = 0; i < a.size(); i++) {
			score += a[i] * b[i];
		}
		return score;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb090
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xe689
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xe720
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xe720
movsd -0x38(%rbp), %xmm0
movsd (%rax), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xe623
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: unit_test_framework::Assertions::assert_true(bool, int, char const*)
static void assert_true(bool value, int line_number,
                            const char* assertion_text) {
      if (value) {
        return;
      }
      std::ostringstream reason;
      reason << "Expected true, but was false";
      throw TestFailure(reason.str(), line_number, assertion_text);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
testb $0x1, -0x1(%rbp)
je 0x8b99
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x3300
movq -0x1c8(%rbp), %rdi
leaq 0x8c5(%rip), %rsi       # 0x947f
callq 0x3220
jmp 0x8bc1
movb $0x1, -0x1b9(%rbp)
movl $0x30, %edi
callq 0x3110
movq %rax, -0x1d0(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x3250
jmp 0x8bee
movq -0x1d0(%rbp), %rdi
movl -0x8(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq -0x1b8(%rbp), %rsi
callq 0x5220
jmp 0x8c0a
movq -0x1d0(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
leaq 0x5121(%rip), %rsi      # 0xdd40
leaq -0x39c6(%rip), %rdx     # 0x5260
callq 0x33a0
jmp 0x8ca4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x8c8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x8c73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x3160
testb $0x1, -0x1b9(%rbp)
jne 0x8c7e
jmp 0x8c8a
movq -0x1d0(%rbp), %rdi
callq 0x31b0
jmp 0x8c8c
leaq -0x188(%rbp), %rdi
callq 0x3080
movq -0x190(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nop
// File: nicluo[P]sorting-numbers/merge.cpp
// Function: next(Seq*)
bool next(Seq* seq) {
    if (seq->source.good()) {
        seq->source >> seq->value;
        return true;
    }
    
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x1180
testb $0x1, %al
jne 0x137a
jmp 0x1391
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x1090
movb $0x1, -0x1(%rbp)
jmp 0x1395
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: nicluo[P]sorting-numbers/merge.cpp
// Function: merge(std::vector<Seq*, std::allocator<Seq*>>&, std::basic_ofstream<char, std::char_traits<char>>&)
void merge(std::vector<Seq*>& sequences, std::ofstream& output) {
    /* Greater<Seq*> comparator for Seq* to create min heap */
    auto comp = []( const Seq* lhs, const Seq* rhs ) { return lhs->value > rhs->value; };
    std::priority_queue<Seq*, std::vector<Seq*>, decltype(comp)> pq(sequences.begin(), sequences.end(), comp);
    
    while(!pq.empty()) {
        /* Get and pop minimum element */
        Seq* top = pq.top();
        pq.pop();
        
        output << top->value << '\n';
        
        /* Since the minimum element is a sequence, if it has a next value,
           we can re-insert into the heap for the next iteration */
        if(next(top)) {
            pq.push(top);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f70
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1fa0
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1fd0
movq -0x80(%rbp), %r8
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rcx
callq 0x1510
jmp 0x1404
leaq -0x60(%rbp), %rdi
callq 0x1ff0
leaq -0x38(%rbp), %rdi
callq 0x1600
movb %al, -0x81(%rbp)
jmp 0x141e
movb -0x81(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x142f
jmp 0x14e6
leaq -0x38(%rbp), %rdi
callq 0x1620
movq %rax, -0x90(%rbp)
jmp 0x1441
movq -0x90(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1640
jmp 0x145a
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rax
movl (%rax), %esi
callq 0x1190
movq %rax, -0x98(%rbp)
jmp 0x1472
movq -0x98(%rbp), %rdi
movl $0xa, %esi
callq 0x1110
jmp 0x1485
movq -0x78(%rbp), %rdi
callq 0x1350
movb %al, -0x99(%rbp)
jmp 0x1496
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x14a2
jmp 0x14e1
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1690
jmp 0x14b1
jmp 0x14e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1ff0
jmp 0x14f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x16e0
jmp 0x14f8
jmp 0x140d
leaq -0x38(%rbp), %rdi
callq 0x16e0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x11a0
nopw %cs:(%rax,%rax)
// File: nicluo[P]sorting-numbers/merge.cpp
// Function: main
int main(int argc, char *argv[]) {
    /* Must provide -o and -f */
    if (argc < 5 || strncmp(argv[1], "-o", 3) != 0 || strncmp(argv[3], "-f", 3) != 0) {
        printUsage(argv[0]);
        return 1;
    }
    
    char* outputFilename = argv[2];
    std::ofstream output(outputFilename);
    
    std::vector<Seq*> sequences = std::vector<Seq*>();
    
    for (int i = 4; i < argc; i++) {
        char* inputFilename = argv[i];
        Seq* seq = new Seq(inputFilename);
        if(next(seq)) {
            sequences.push_back(seq);
        }
    }
    
    merge(sequences, output);
    output.close();
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x5, -0x8(%rbp)
jl 0x175b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x3900(%rip), %rsi      # 0x502e
movl $0x3, %edx
callq 0x1060
cmpl $0x0, %eax
jne 0x175b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x38e5(%rip), %rsi      # 0x5031
movl $0x3, %edx
callq 0x1060
cmpl $0x0, %eax
je 0x1773
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1300
movl $0x1, -0x4(%rbp)
jmp 0x18fc
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x1100
leaq -0x230(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x1080
leaq -0x230(%rbp), %rdi
callq 0x1fd0
movl $0x4, -0x234(%rbp)
movl -0x234(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x189e
movq -0x10(%rbp), %rax
movslq -0x234(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x240(%rbp)
movl $0x210, %edi            # imm = 0x210
callq 0x10d0
movq %rax, -0x260(%rbp)
jmp 0x17f5
movq -0x260(%rbp), %rdi
movq -0x240(%rbp), %rsi
callq 0x2050
jmp 0x180a
movq -0x260(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x248(%rbp), %rdi
callq 0x1350
movb %al, -0x261(%rbp)
jmp 0x182c
movb -0x261(%rbp), %al
testb $0x1, %al
jne 0x1838
jmp 0x1888
leaq -0x230(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x2080
jmp 0x184d
jmp 0x1888
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
jmp 0x18e2
movq -0x260(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
movl $0x210, %esi            # imm = 0x210
callq 0x10e0
jmp 0x18e2
jmp 0x188a
movl -0x234(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x234(%rbp)
jmp 0x17bd
leaq -0x230(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x13a0
jmp 0x18b3
leaq -0x218(%rbp), %rdi
callq 0x1120
jmp 0x18c1
movl $0x0, -0x4(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x1ff0
leaq -0x218(%rbp), %rdi
callq 0x1140
jmp 0x18fc
leaq -0x230(%rbp), %rdi
callq 0x1ff0
leaq -0x218(%rbp), %rdi
callq 0x1140
jmp 0x1908
movl -0x4(%rbp), %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x250(%rbp), %rdi
callq 0x11a0
nopw %cs:(%rax,%rax)
// File: KokiKishimoto[P]cp_decomposition/./signal_operation.hpp
// Function: SignalOperation::qproduct(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
double qproduct(const std::vector<double>& a, const std::vector<double>& b, const std::vector<double>& c, std::vector<double>& out1, std::vector<double>& out2, std::vector<double>& out3){
		double score = 0.0;
		for(int i = 0; i < a.size(); i++){
			double a_ = quantize(a[i]);
			double b_ = quantize(b[i]);
			double c_ = quantize(c[i]);
			out1[i] = a_ * b_;
			out2[i] = b_ * c_;
			out3[i] = c_ * a_;
			score += c_ * out1[i];
		}
		return score;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movslq -0x3c(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaad0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0xe64e
movq -0x10(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0xe720
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xe6e0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0xe720
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xe6e0
movsd %xmm0, -0x50(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0xe720
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xe6e0
movsd %xmm0, -0x58(%rbp)
movsd -0x48(%rbp), %xmm0
mulsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x9ae0
movsd -0x88(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x50(%rbp), %xmm0
mulsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x9ae0
movsd -0x80(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x58(%rbp), %xmm0
mulsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movq 0x10(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x9ae0
movsd -0x78(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x9ae0
movsd -0x70(%rbp), %xmm0
movsd (%rax), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xe51e
movsd -0x38(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: KokiKishimoto[P]cp_decomposition/./signal_operation.hpp
// Function: SignalOperation::quantize(double const&)
double quantize(const double& x) {
		if(x < 0){
			return -1.0 / 3.0;
		}else{
			return 1.0 /3.0;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0xe708
movsd 0x1937(%rip), %xmm0     # 0x10038
movsd %xmm0, -0x8(%rbp)
jmp 0xe715
movsd 0x1920(%rip), %xmm0     # 0x10030
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/refret-ex.cc
// Function: main
int main() {
    int ia[10];  // array of ten uninitialized ints

    for (int i = 0; i != 10; ++i)
        get(ia, i) = i;  // call get to assign values to the elements

	for (auto i : ia)    // print the elements
		cout << i << " ";
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
je 0x121e
movl -0x34(%rbp), %eax
movl %eax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x11c0
movl -0x58(%rbp), %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x11f6
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0x1279
movq -0x48(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %esi
movq 0x2d81(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xd9e(%rip), %rsi       # 0x2004
callq 0x1040
movq -0x48(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x48(%rbp)
jmp 0x123a
movq 0x2d58(%rip), %rdi      # 0x3fd8
movq 0x2d41(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
// File: blakewford[P]kab/main.cpp
// Function: buildServerType(unsigned int, unsigned short)
struct sockaddr_in buildServerType(in_addr_t address, in_port_t port)
{
    struct sockaddr_in server;
    memset(&server, '\0', sizeof(server));

    server.sin_family = AF_INET;
    server.sin_addr.s_addr = address;
    server.sin_port = htons(port);

    return server;
}

// Assembly:
subq $0x28, %rsp
movw %si, %ax
movl %edi, 0xc(%rsp)
movw %ax, 0xa(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movw $0x2, 0x10(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
movzwl 0xa(%rsp), %edi
callq 0x2040
movw %ax, 0x12(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: blakewford[P]kab/main.cpp
// Function: buildQuery()
void buildQuery()
{
    memset(query, '\0', sizeof(query));

    time_t now = time(nullptr);
    now += 20637;
    now = bswap_32(now) >> 16;

    query[24] = 0xE2;
    query[25] = 0x07;
    query[26] = 0x0C;
    query[27] = 0x09;
    query[28] = now >> 8;
    query[29] = now & 0x00FF;
}

// Assembly:
pushq %rax
leaq 0x9c78(%rip), %rdi      # 0xc240
xorl %esi, %esi
movl $0x80, %edx
callq 0x2130
xorl %eax, %eax
movl %eax, %edi
callq 0x2200
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x509d, %rax           # imm = 0x509D
movq %rax, (%rsp)
movq (%rsp), %rax
movl %eax, %edi
callq 0x2640
shrl $0x10, %eax
movl %eax, %eax
movq %rax, (%rsp)
movb $-0x1e, 0x9c4e(%rip)    # 0xc258
movb $0x7, 0x9c48(%rip)      # 0xc259
movb $0xc, 0x9c42(%rip)      # 0xc25a
movb $0x9, 0x9c3c(%rip)      # 0xc25b
movq (%rsp), %rax
sarq $0x8, %rax
movb %al, 0x9c2f(%rip)       # 0xc25c
movq (%rsp), %rax
andq $0xff, %rax
movb %al, 0x9c20(%rip)       # 0xc25d
popq %rax
retq
nop
// File: blakewford[P]kab/main.cpp
// Function: initializeCommand(command&)
void initializeCommand(command& c)
{
    memset(&c, '\0', sizeof(command));

    c.cmd     = MODIFY_SWITCH;
    c.counter = 0x55555555;
    c.type    = 2;
    c.op      = 2;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x82, %edx
callq 0x2130
movq (%rsp), %rax
movl $0x50016, (%rax)        # imm = 0x50016
movq (%rsp), %rax
movl $0x55555555, 0x74(%rax) # imm = 0x55555555
movq (%rsp), %rax
movw $0x2, 0x8(%rax)
movq (%rsp), %rax
movb $0x2, 0x80(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: blakewford[P]kab/main.cpp
// Function: toggle(unsigned long, bool)
void toggle(size_t ndx, bool on)
{
    response r = gFound.at(ndx);

    srand(time(nullptr));
    int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    struct sockaddr_in target = buildServerType(inet_addr(r.ip), COMMAND_PORT);

    command toggle;
    initializeCommand(toggle);

    toggle.id = rand();
    memcpy(toggle.model, r.model, 32);
    toggle.value = on;

    ssize_t sent = sendto(sock, &toggle, sizeof(command), 0, (sockaddr*)&target, sizeof(target));
    close(sock);
}

// Assembly:
subq $0x248, %rsp            # imm = 0x248
movb %sil, %al
movq %rdi, 0x240(%rsp)
andb $0x1, %al
movb %al, 0x23f(%rsp)
movq 0x240(%rsp), %rsi
leaq 0x9bfe(%rip), %rdi      # 0xc2f8
callq 0x38d0
movq %rax, %rsi
leaq 0xa7(%rsp), %rdi
movl $0x198, %edx            # imm = 0x198
callq 0x21c0
xorl %eax, %eax
movl %eax, %edi
callq 0x2200
movl %eax, %edi
callq 0x2220
movl $0x2, %esi
movl $0x11, %edx
movl %esi, %edi
callq 0x2080
movl %eax, 0xa0(%rsp)
leaq 0xa7(%rsp), %rdi
addq $0x182, %rdi            # imm = 0x182
callq 0x2250
movl %eax, %edi
movl $0x50, %esi
callq 0x2570
movq %rax, 0x90(%rsp)
movq %rdx, 0x98(%rsp)
leaq 0xe(%rsp), %rdi
callq 0x2680
callq 0x20a0
movl %eax, 0x12(%rsp)
movq 0xb1(%rsp), %rax
movq %rax, 0x1e(%rsp)
movq 0xb9(%rsp), %rax
movq %rax, 0x26(%rsp)
movq 0xc1(%rsp), %rax
movq %rax, 0x2e(%rsp)
movq 0xc9(%rsp), %rax
movq %rax, 0x36(%rsp)
movb 0x23f(%rsp), %al
andb $0x1, %al
movb %al, 0x8f(%rsp)
movl 0xa0(%rsp), %edi
leaq 0xe(%rsp), %rsi
movl $0x82, %edx
xorl %ecx, %ecx
leaq 0x90(%rsp), %r8
movl $0x10, %r9d
callq 0x2050
movq %rax, (%rsp)
movl 0xa0(%rsp), %edi
callq 0x23f0
addq $0x248, %rsp            # imm = 0x248
retq
nopw %cs:(%rax,%rax)