LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::shrink()
void shrink(void) {
    cellType i = cell.size();
    cellType rem = 0;

    if (i == 0) {
      negative = false;
      return;
    }

    while (i > 0) {
      i--;

      if (cell[i] == cellType(0)) {
        rem++;
      } else {
        break;
      }
    }

    if (rem == 0) {
      return;
    }

    cell.resize(cell.size() - rem);

    if (cell.size() == 0) {
      negative = false;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x3c9c0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x3e4b9
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
jmp 0x3e53c
jmp 0x3e4bb
cmpl $0x0, -0xc(%rbp)
jbe 0x3e4f0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
addq $0x8, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x3c3f0
cmpl $0x0, (%rax)
jne 0x3e4ec
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3e4ee
jmp 0x3e4f0
jmp 0x3e4bb
cmpl $0x0, -0x10(%rbp)
jne 0x3e4f8
jmp 0x3e53c
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x3c9c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x10(%rbp), %eax
subq %rax, %rsi
callq 0x3c360
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c9c0
cmpq $0x0, %rax
jne 0x3e53c
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::doModuloHorner(efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&, unsigned int const&, bool)
void doModuloHorner(const bigIntegers &a, const cellType &b,
                      bool allocate = true) {
    Tu modulus = Tu(b);
    Tu result = Tu(0);
    const Tu factor = (Tu(1) << cellBitCount) % modulus;

    for (cellType i = a.cell.size(); i > 0; i--) {
      result *= factor;
      result %= modulus;
      result += (Tu(a.cell[(i - 1)]) % modulus);
      result %= modulus;
    }

    cell.resize(1);

    cell[0] = result;

    shrink();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movabsq $0x100000000, %rax      # imm = 0x100000000
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c9c0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jbe 0x3f364
movq -0x38(%rbp), %rax
imulq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3d8a0
movl (%rax), %eax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rbp)
addq -0x30(%rbp), %rdx
movq %rdx, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x30(%rbp)
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3f2fb
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x3c360
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, -0x4c(%rbp)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3c3f0
movl -0x4c(%rbp), %ecx
movq -0x48(%rbp), %rdi
movl %ecx, (%rax)
callq 0x3e480
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::doModulo(efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&, efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&, bool)
void doModulo(const bigIntegers &a, const bigIntegers &b,
                bool allocate = true) {
    cell.resize(0);

    for (cellType i = a.cell.size(); i > 0; i--) {
      cellType ir = i - 1;
      cellType c = a.cell[ir];

      for (cellType j = cellBitCount; j > 0; j--) {
        cellType jr = j - 1;

        *this <<= 1;

        if (c & (1 << jr)) {
          if (cell.size() == 0) {
            cell.resize(1);
            cell[0] = cellType(1);
          } else {
            cell[0] |= 1;
          }
        }

        if (*this >= b) {
          *this -= b;
        }
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3c360
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c9c0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jbe 0x3f4f6
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3d8a0
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x20, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jbe 0x3f4e6
movq -0x40(%rbp), %rdi
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0xfb10
movl -0x28(%rbp), %eax
movl -0x30(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x3f4b6
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c9c0
cmpq $0x0, %rax
jne 0x3f49c
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x3c360
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3c3f0
movl $0x1, (%rax)
jmp 0x3f4b4
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3c3f0
movl (%rax), %ecx
orl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x3f4b6
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3f500
testb $0x1, %al
jne 0x3f4c9
jmp 0x3f4d6
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3f550
jmp 0x3f4d8
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3f421
jmp 0x3f4e8
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3f3f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::operator==(efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&) const
bool operator==(const bigIntegers &b) const {
    if (cell.size() != b.cell.size()) {
      return false;
    }

    if (negative != b.negative) {
      return false;
    }

    for (cellType i = 0; i < cell.size(); i++) {
      if (cell[i] != b.cell[i]) {
        return false;
      }
    }

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0x3c9c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c9c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x3f607
movb $0x0, -0x1(%rbp)
jmp 0x3f699
movq -0x30(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x3f628
movb $0x0, -0x1(%rbp)
jmp 0x3f699
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0x3c9c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x3f695
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x3d8a0
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x3d8a0
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl (%rcx), %eax
je 0x3f688
movb $0x0, -0x1(%rbp)
jmp 0x3f699
jmp 0x3f68a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f62f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void load(std::string filename) {

            const char * cfilename = filename.c_str();
            std::ifstream file(cfilename, std::ios::binary);

            file.seekg(0, file.end);
            int fileSizeInBytes = file.tellg();
            file.seekg(0, file.beg);

            int numberOfSamples = fileSizeInBytes / (sizeof(T) * channels);
            std::cout << sizeof(T) << '\n';
            data_vector.resize(numberOfSamples);

            file.read((char*)&data_vector[0], fileSizeInBytes);
            std::cout << "File loaded." << '\n';
            file.close();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rsi, -0x260(%rbp)
movq %rdi, %rax
movq -0x260(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x258(%rbp)
callq 0x20a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movq %rdi, -0x250(%rbp)
movl $0x4, %edx
callq 0x22b0
movq -0x250(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21c0
jmp 0x693b
leaq -0x220(%rbp), %rdi
callq 0x2270
movq %rdx, -0x270(%rbp)
movq %rax, -0x268(%rbp)
jmp 0x6957
movq -0x270(%rbp), %rax
movq -0x268(%rbp), %rcx
movq %rcx, -0x240(%rbp)
movq %rax, -0x238(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x9dd0
movq %rax, -0x278(%rbp)
jmp 0x6988
movq -0x278(%rbp), %rax
movl %eax, -0x230(%rbp)
xorl %edx, %edx
movl %edx, %esi
leaq -0x220(%rbp), %rdi
callq 0x21c0
jmp 0x69a7
movq -0x258(%rbp), %rcx
movslq -0x230(%rbp), %rax
movslq 0x18(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movl %eax, -0x244(%rbp)
movq 0x1360d(%rip), %rdi     # 0x19fd8
movl $0x1, %esi
callq 0x2040
movq %rax, -0x280(%rbp)
jmp 0x69de
movq -0x280(%rbp), %rdi
movl $0xa, %esi
callq 0x2170
jmp 0x69f1
movq -0x258(%rbp), %rdi
movslq -0x244(%rbp), %rsi
callq 0x9df0
jmp 0x6a06
movq -0x258(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9e80
movq %rax, %rsi
movslq -0x230(%rbp), %rdx
leaq -0x220(%rbp), %rdi
callq 0x21a0
jmp 0x6a2e
movq 0x135a3(%rip), %rdi     # 0x19fd8
leaq 0xb63a(%rip), %rsi      # 0x12076
callq 0x2130
movq %rax, -0x288(%rbp)
jmp 0x6a4a
movq -0x288(%rbp), %rdi
movl $0xa, %esi
callq 0x2170
jmp 0x6a5d
leaq -0x220(%rbp), %rdi
callq 0x2030
jmp 0x6a6b
leaq -0x220(%rbp), %rdi
callq 0x2050
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x2050
movq -0x228(%rbp), %rdi
callq 0x2290
nopw (%rax,%rax)
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::operator+(MRXADA002::Audio<signed char, 1> const&)
Audio<T, N> operator+(const Audio<T, N> & rhs) {
            Audio<T, N> a(*this);
            int m = std::min(a.data_vector.size(), rhs.data_vector.size());
            for (int i = 0; i < m; ++i) {
                int newVal = a.data_vector[i] + rhs.data_vector[i]; //add amplitudes
                if (sizeof(T)==1) {
                    if (newVal > INT8_MAX) {    //clamp value for  8 bit
                        newVal = INT8_MAX;
                    }
                    a.data_vector[i] = newVal;
                }
                if (sizeof(T)==2) {             //clamp value for 16 bit
                    if (newVal > INT16_MAX) {
                        newVal = INT16_MAX;
                    }
                    a.data_vector[i] = newVal;
                }
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0xa800
movq -0x40(%rbp), %rdi
callq 0x9ea0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9ea0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa3a0
movq (%rax), %rax
movl %eax, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6b76
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x9e80
movsbl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xa840
movq %rax, %rcx
movl -0x4c(%rbp), %eax
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x38(%rbp)
cmpl $0x7f, -0x38(%rbp)
jle 0x6b53
movl $0x7f, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %eax
movb %al, -0x4d(%rbp)
movslq -0x34(%rbp), %rsi
callq 0x9e80
movb -0x4d(%rbp), %cl
movb %cl, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6b10
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x6b89
movq -0x40(%rbp), %rdi
callq 0x6cf0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::save(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void save(std::string filename) {
            filename = filename + ".raw";
            const char * cfilename = filename.c_str();
            std::ofstream file(cfilename, std::ios::binary);

            int fileSizeInBytes = data_vector.size() * sizeof(T) * channels; //calculate bytes to be written
            file.write((char*)&data_vector[0], fileSizeInBytes);
            std::cout << "File saved." << '\n';
            file.close();

        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rsi, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x260(%rbp)
leaq 0xb4d1(%rip), %rdx      # 0x1209d
leaq -0x30(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0xae20
movq -0x270(%rbp), %rsi
movq -0x268(%rbp), %rdi
callq 0x2180
movq -0x270(%rbp), %rdi
callq 0x20e0
movq -0x268(%rbp), %rdi
callq 0x20a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x238(%rbp), %rdi
movq %rdi, -0x258(%rbp)
movl $0x4, %edx
callq 0x2160
movq -0x260(%rbp), %rdi
callq 0x9ea0
movq -0x260(%rbp), %rdi
movl 0x18(%rdi), %ecx
imull %ecx, %eax
movl %eax, -0x23c(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x9e80
movq -0x258(%rbp), %rdi
movq %rax, %rsi
movslq -0x23c(%rbp), %rdx
callq 0x21b0
jmp 0x6c67
movq 0x1336a(%rip), %rdi     # 0x19fd8
leaq 0xb42d(%rip), %rsi      # 0x120a2
callq 0x2130
movq %rax, -0x278(%rbp)
jmp 0x6c83
movq -0x278(%rbp), %rdi
movl $0xa, %esi
callq 0x2170
jmp 0x6c96
leaq -0x238(%rbp), %rdi
callq 0x2200
jmp 0x6ca4
leaq -0x238(%rbp), %rdi
callq 0x2220
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x2220
movq -0x248(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::operator|(MRXADA002::Audio<signed char, 1> const&)
Audio<T, N> operator|(const Audio<T,N> & rhs) {
            Audio<T, N> a(*this);                       //use copy constructor on lhs audio
            for (int i = 0; i < rhs.data_vector.size(); ++i) {
                a.data_vector.push_back(rhs.data_vector[i]);         //append rhs's values onto data_vector
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0xa800
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9ea0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x7b0f
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xa840
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xdeb0
jmp 0x7aeb
jmp 0x7aed
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7ab3
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6cf0
jmp 0x7b2c
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7b22
movq -0x40(%rbp), %rdi
callq 0x6cf0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
nop
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::operator|(MRXADA002::Audio<signed char, 2> const&)
Audio<T, 2> operator|(const Audio<T,2> & rhs) {
            Audio<T, 2> a(*this);                       //use copy constructor on lhs audio
            for (int i = 0; i < rhs.data_vector.size(); ++i) {
                a.data_vector.push_back(rhs.data_vector[i]);         //append rhs's values onto data_vector
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0xc970
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc0a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x7c8f
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xc9b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xe4c0
jmp 0x7c6b
jmp 0x7c6d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7c33
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x75d0
jmp 0x7cac
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7ca2
movq -0x40(%rbp), %rdi
callq 0x75d0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
nop
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::operator*(std::pair<float, float>)
Audio<T, N> operator*( std::pair<float, float> rhs) {
            Audio<T, N> a(*this);               //use copy constructor
            for (int i = 0; i < a.data_vector.size(); ++i) {
                a.data_vector[i]*=rhs.first; //scale amplitude
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movlpd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0xa800
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x9ea0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x7e3f
movq -0x30(%rbp), %rdi
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x9e80
movss -0x3c(%rbp), %xmm1
movq %rax, %rcx
movq %rcx, %rax
movsbl (%rcx), %ecx
cvtsi2ss %ecx, %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movb %cl, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7de4
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7e52
movq -0x30(%rbp), %rdi
callq 0x6cf0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::operator*(std::pair<float, float>)
Audio<T, 2> operator*( std::pair<float, float> rhs) {
            Audio<T, 2> a(*this);                       //use copy constructor
            for (int i = 0; i < a.data_vector.size(); ++i) {
                a.data_vector[i].first*=rhs.first;  //scale amplitude
                a.data_vector[i].second*=rhs.second;
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movlpd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0xc970
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xc0a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x7fd1
movq -0x30(%rbp), %rdi
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
movslq -0x20(%rbp), %rsi
callq 0xc080
movss -0x40(%rbp), %xmm1
movq -0x30(%rbp), %rdi
movsbl (%rax), %ecx
cvtsi2ss %ecx, %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movb %cl, (%rax)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movslq -0x20(%rbp), %rsi
callq 0xc080
movss -0x3c(%rbp), %xmm1
movq %rax, %rcx
movq %rcx, %rax
movsbl 0x1(%rcx), %ecx
cvtsi2ss %ecx, %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movb %cl, 0x1(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7f44
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7fe4
movq -0x30(%rbp), %rdi
callq 0x75d0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::operator^(std::pair<int, int>)
Audio<T, N> operator^(std::pair<int, int> rhs ) {
            Audio<T, N> a;
            for (int i = 0; i < rhs.first; ++i) {
                a.data_vector.push_back(this->data_vector[i]);
            }
            for (int i = rhs.second + 1; i < this->data_vector.size(); ++i) {
                a.data_vector.push_back(this->data_vector[i]);
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x68a0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x817e
movq -0x38(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x9e80
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xdeb0
jmp 0x815a
jmp 0x815c
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8137
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6cf0
jmp 0x81e9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x9ea0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x81cc
movq -0x38(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x9e80
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xdeb0
jmp 0x81bf
jmp 0x81c1
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x8187
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x81df
movq -0x48(%rbp), %rdi
callq 0x6cf0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::operator^(std::pair<int, int>)
Audio<T, 2> operator^(std::pair<int, int> rhs ) {
            Audio<T, 2> a;
            for (int i = 0; i < rhs.first; ++i) {
                a.data_vector.push_back(this->data_vector[i]);
            }
            for (int i = rhs.second + 1; i < this->data_vector.size(); ++i) {
                a.data_vector.push_back(this->data_vector[i]);
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7170
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x837e
movq -0x38(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xc080
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xe4c0
jmp 0x835a
jmp 0x835c
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8337
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x75d0
jmp 0x83e9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0xc0a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x83cc
movq -0x38(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0xc080
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xe4c0
jmp 0x83bf
jmp 0x83c1
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x8387
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x83df
movq -0x48(%rbp), %rdi
callq 0x75d0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::ranged_add(MRXADA002::Audio<signed char, 1> const&, int, int)
Audio<T, N> ranged_add(const Audio<T,N> & rhs, int rangeStart, int rangeEnd) {
            Audio<T, N> range1;
            range1.data_vector.resize(rangeEnd-rangeStart);
            Audio<T, N> range2;
            range2.data_vector.resize(rangeEnd-rangeStart);
            std::copy(this->data_vector.begin()+rangeStart, this->data_vector.begin()+rangeEnd, range1.data_vector.begin());
            std::copy(rhs.data_vector.begin()+rangeStart, rhs.data_vector.begin()+rangeEnd, range2.data_vector.begin());
            Audio<T, N> out = range1 + range2;
            return out;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x68a0
movq -0xe0(%rbp), %rdi
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl %ecx, %eax
movslq %eax, %rsi
callq 0x9df0
jmp 0x86a3
leaq -0x70(%rbp), %rdi
callq 0x68a0
jmp 0x86ae
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl %ecx, %eax
movslq %eax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x9df0
jmp 0x86c4
movq -0xe8(%rbp), %rdi
callq 0xe150
movq %rax, -0x80(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0xf460
movq -0xe8(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0xe150
movq %rax, -0x90(%rbp)
movslq -0x20(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0xf460
movq %rax, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xe150
movq %rax, -0x98(%rbp)
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0xf3f0
movq %rax, -0x100(%rbp)
jmp 0x873f
movq -0x100(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaa40
movq %rax, -0xb0(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0xf510
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaa40
movq %rax, -0xc0(%rbp)
movslq -0x20(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0xf510
movq %rax, -0xb8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xe150
movq %rax, -0xc8(%rbp)
movq -0xa8(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0xf4a0
movq %rax, -0x108(%rbp)
jmp 0x87ce
movq -0xf8(%rbp), %rdi
movq -0x108(%rbp), %rax
movq %rax, -0xd0(%rbp)
movb $0x0, -0xd1(%rbp)
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x6ab0
jmp 0x87f9
movb $0x1, -0xd1(%rbp)
testb $0x1, -0xd1(%rbp)
jne 0x883c
jmp 0x8830
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x885e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x6cf0
jmp 0x885e
movq -0xf8(%rbp), %rdi
callq 0x6cf0
leaq -0x70(%rbp), %rdi
callq 0x6cf0
leaq -0x40(%rbp), %rdi
callq 0x6cf0
movq -0xf0(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x6cf0
movq -0x48(%rbp), %rdi
callq 0x2290
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::ranged_add(MRXADA002::Audio<signed char, 2> const&, int, int)
Audio<T, 2> ranged_add(const Audio<T,2> & rhs, int rangeStart, int rangeEnd) {
            Audio<T, 2> range1;
            range1.data_vector.resize(rangeEnd-rangeStart);
            Audio<T, 2> range2;
            range2.data_vector.resize(rangeEnd-rangeStart);
            std::copy(this->data_vector.begin()+rangeStart, this->data_vector.begin()+rangeEnd, range1.data_vector.begin());
            std::copy(rhs.data_vector.begin()+rangeStart, rhs.data_vector.begin()+rangeEnd, range2.data_vector.begin());
            Audio<T, 2> out = range1 + range2;
            return out;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x7170
movq -0xe0(%rbp), %rdi
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl %ecx, %eax
movslq %eax, %rsi
callq 0xbff0
jmp 0x8b03
leaq -0x70(%rbp), %rdi
callq 0x7170
jmp 0x8b0e
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl %ecx, %eax
movslq %eax, %rsi
leaq -0x70(%rbp), %rdi
callq 0xbff0
jmp 0x8b24
movq -0xe8(%rbp), %rdi
callq 0xe770
movq %rax, -0x80(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0xfb40
movq -0xe8(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0xe770
movq %rax, -0x90(%rbp)
movslq -0x20(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0xfb40
movq %rax, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xe770
movq %rax, -0x98(%rbp)
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0xfad0
movq %rax, -0x100(%rbp)
jmp 0x8b9f
movq -0x100(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0xcbb0
movq %rax, -0xb0(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0xfbf0
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
callq 0xcbb0
movq %rax, -0xc0(%rbp)
movslq -0x20(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0xfbf0
movq %rax, -0xb8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xe770
movq %rax, -0xc8(%rbp)
movq -0xa8(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0xfb80
movq %rax, -0x108(%rbp)
jmp 0x8c2e
movq -0xf8(%rbp), %rdi
movq -0x108(%rbp), %rax
movq %rax, -0xd0(%rbp)
movb $0x0, -0xd1(%rbp)
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x7340
jmp 0x8c59
movb $0x1, -0xd1(%rbp)
testb $0x1, -0xd1(%rbp)
jne 0x8c9c
jmp 0x8c90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8cbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x75d0
jmp 0x8cbe
movq -0xf8(%rbp), %rdi
callq 0x75d0
leaq -0x70(%rbp), %rdi
callq 0x75d0
leaq -0x40(%rbp), %rdi
callq 0x75d0
movq -0xf0(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x75d0
movq -0x48(%rbp), %rdi
callq 0x2290
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::rms()
std::pair<double, double> rms() {
            double left = sqrt(std::accumulate(this->data_vector.begin(), this->data_vector.end(), 0.0, [&](double a, std::pair<T,T> b){return a + pow(b.first, 2)/this->data_vector.size();}));
            double right = sqrt(std::accumulate(this->data_vector.begin(), this->data_vector.end(), 0.0, [&](double a, std::pair<T,T> b){return a + pow(b.second, 2)/this->data_vector.size();}));
            std::pair<double, double> ans (left, right);
            return ans;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xe770
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0xe6e0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
callq 0x107c0
callq 0x2100
movq -0x60(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
callq 0xe770
movq -0x60(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0xe6e0
movsd -0x68(%rbp), %xmm0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x10840
callq 0x2100
movsd %xmm0, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x9140
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x70, %rsp
popq %rbp
retq
nop
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::normalize(std::pair<double, double>)
Audio<T, N> normalize(std::pair<double, double> rms) {
            Audio<T, N> a(*this);
            Normalize functor(rms.first);
            std::transform(this->data_vector.begin(), this->data_vector.end(), a.data_vector.begin(), functor);
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq %rsi, -0x70(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xa800
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x10cc0
jmp 0x91b8
movq -0x70(%rbp), %rdi
callq 0xe150
movq -0x70(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0xe0c0
movq -0x80(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0xe150
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0x10ce0
movq %rax, -0x88(%rbp)
jmp 0x9205
movq -0x88(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x923c
jmp 0x9233
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x6cf0
jmp 0x9249
movq -0x80(%rbp), %rdi
callq 0x6cf0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::normalize(std::pair<double, double>)
Audio<T, 2> normalize(std::pair<double, double> rms) {
            Audio<T, 2> a(*this);
            Normalize functor(rms);
            std::transform(this->data_vector.begin(), this->data_vector.end(), a.data_vector.begin(), functor);
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq %rsi, -0x70(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xc970
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x10e90
jmp 0x9398
movq -0x70(%rbp), %rdi
callq 0xe770
movq -0x70(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0xe6e0
movq -0x80(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0xe770
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0x10eb0
movq %rax, -0x88(%rbp)
jmp 0x93e5
movq -0x88(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x941c
jmp 0x9413
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x75d0
jmp 0x9429
movq -0x80(%rbp), %rdi
callq 0x75d0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::Normalize::operator()(signed char const&)
T operator()(const T & vectorVal) {
                int out = (int)(*ptr * vectorVal);
                if (sizeof(T)==1) {
                    if (out > INT8_MAX) {    //clamp value for  8 bit
                        out = INT8_MAX;
                    }
                }
                if (sizeof(T)==2) {
                    if (out > INT16_MAX) {    //clamp value for  16 bit
                        out = INT16_MAX;
                    }
                }
                return out;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
cmpl $0x7f, -0x14(%rbp)
jle 0x10d9a
movl $0x7f, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::Normalize::operator()(std::pair<signed char, signed char>)
std::pair<T, T> operator()(std::pair<T, T> vectorVal) {
                std::pair<T, T> out;               //output pair
                int outLeft = (int)(vectorVal.first * ptr->first);
                int outRight = (int)(vectorVal.second * ptr->second);
                if (sizeof(T)==1) {
                    if (outLeft > INT8_MAX) {    //clamp value for  8 bit
                        outLeft = INT8_MAX;
                    }
                    if (outRight > INT8_MAX) {    //clamp value for  8 bit
                        outRight = INT8_MAX;
                    }
                }
                if (sizeof(T)==2) {
                    if (outLeft > INT16_MAX) {    //clamp value for  16 bit
                        outLeft = INT16_MAX;
                    }
                    if (outRight > INT16_MAX) {    //clamp value for  16 bit
                        outRight = INT16_MAX;
                    }
                }
                out.first = outLeft;
                out.second = outRight;
                return out;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movw %ax, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x2(%rbp), %rdi
callq 0xc6e0
movq -0x20(%rbp), %rax
movsbl -0x4(%rbp), %ecx
cvtsi2sd %ecx, %xmm0
movq (%rax), %rcx
mulsd (%rcx), %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, -0x14(%rbp)
movsbl -0x3(%rbp), %ecx
cvtsi2sd %ecx, %xmm0
movq (%rax), %rax
mulsd 0x8(%rax), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
cmpl $0x7f, -0x14(%rbp)
jle 0x10fa2
movl $0x7f, -0x14(%rbp)
cmpl $0x7f, -0x18(%rbp)
jle 0x10faf
movl $0x7f, -0x18(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x2(%rbp)
movl -0x18(%rbp), %eax
movb %al, -0x1(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: rksdna[P]json/./json.hpp
// Function: json::basic_reader<char, std::char_traits<char>, std::allocator<char>>::unicode(char)
inline void unicode(char_type input)
    {
        std::uint16_t digit = 0;

        if (input >= '0' && input <= '9')
            digit = input - '0';
        else if (input >= 'a' && input <= 'f')
            digit = input - 'a' + 10;
        else if (input >= 'A' && input <= 'F')
            digit = input - 'A' + 10;
        else
            throw std::bad_exception();

        m_unicode = (m_unicode << 4) | digit;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw $0x0, -0xc(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x30, %eax
jl 0x89af
movsbl -0x9(%rbp), %eax
cmpl $0x39, %eax
jg 0x89af
movsbl -0x9(%rbp), %eax
subl $0x30, %eax
movw %ax, -0xc(%rbp)
jmp 0x8a24
movsbl -0x9(%rbp), %eax
cmpl $0x61, %eax
jl 0x89d1
movsbl -0x9(%rbp), %eax
cmpl $0x66, %eax
jg 0x89d1
movsbl -0x9(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movw %ax, -0xc(%rbp)
jmp 0x8a22
movsbl -0x9(%rbp), %eax
cmpl $0x41, %eax
jl 0x89f3
movsbl -0x9(%rbp), %eax
cmpl $0x46, %eax
jg 0x89f3
movsbl -0x9(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movw %ax, -0xc(%rbp)
jmp 0x8a20
movl $0x8, %edi
callq 0x20d0
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
callq 0x5780
movq -0x20(%rbp), %rdi
movq 0x75ac(%rip), %rsi      # 0xffc0
movq 0x7585(%rip), %rdx      # 0xffa0
callq 0x22a0
jmp 0x8a22
jmp 0x8a24
movq -0x18(%rbp), %rax
movzwl 0xa8(%rax), %ecx
shll $0x4, %ecx
movzwl -0xc(%rbp), %edx
orl %edx, %ecx
movw %cx, 0xa8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: rksdna[P]json/./json.hpp
// Function: json::basic_reader<char, std::char_traits<char>, std::allocator<char>>::take_unicode()
inline void take_unicode()
    {
        if (m_unicode < 0x80)
        {
            m_data.push_back(char_type(m_unicode));
        }
        else if (m_unicode < 0x800)
        {
            m_data.push_back(char_type(0xC0 | ((m_unicode >> 6) & 0x1F)));
            m_data.push_back(char_type(0x80 | ((m_unicode) & 0x3F)));
        }
        else
        {
            m_data.push_back(char_type(0xE0 | ((m_unicode >> 12) & 0x0F)));
            m_data.push_back(char_type(0x80 | ((m_unicode >> 6) & 0x3F)));
            m_data.push_back(char_type(0x80 | ((m_unicode) & 0x3F)));
        }

        m_unicode = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movzwl 0xa8(%rax), %eax
cmpl $0x80, %eax
jge 0x8a91
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x78, %rdi
movw 0xa8(%rax), %ax
movsbl %al, %esi
callq 0x2160
jmp 0x8b5a
movq -0x10(%rbp), %rax
movzwl 0xa8(%rax), %eax
cmpl $0x800, %eax            # imm = 0x800
jge 0x8aec
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x78, %rdi
movzwl 0xa8(%rax), %eax
sarl $0x6, %eax
andl $0x1f, %eax
orl $0xc0, %eax
movsbl %al, %esi
callq 0x2160
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x78, %rdi
movzwl 0xa8(%rax), %eax
andl $0x3f, %eax
orl $0x80, %eax
movsbl %al, %esi
callq 0x2160
jmp 0x8b58
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x78, %rdi
movzwl 0xa8(%rax), %eax
sarl $0xc, %eax
andl $0xf, %eax
orl $0xe0, %eax
movsbl %al, %esi
callq 0x2160
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x78, %rdi
movzwl 0xa8(%rax), %eax
sarl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movsbl %al, %esi
callq 0x2160
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x78, %rdi
movzwl 0xa8(%rax), %eax
andl $0x3f, %eax
orl $0x80, %eax
movsbl %al, %esi
callq 0x2160
jmp 0x8b5a
movq -0x10(%rbp), %rax
movw $0x0, 0xa8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: wenleix[P]EdgePPR/src/GenCSRMatrix.cpp
// Function: main
int main(int argc, char **argv) {
	if (argc != 4) {
		fprintf(stderr, "Usage: %s [ParamGraph.txt] [CSC-Prefix] [CSC-Suffix]\n", argv[0]);
		return 1;
	}

	FILE *gfile = fopen(argv[1], "r");
	char *cscPrefix = argv[2];
    char *suffix = argv[3];

	ParamGraph *g = ParamGraph::ReadTextFile(gfile);
	for (int i = 0; i < ParamGraph_NumEdgeTypes; i++) {
		char fnameBuf[1000];
		sprintf(fnameBuf, "%s%d.%s", cscPrefix, i, suffix);
        if (strcmp(suffix, "txt") == 0) {
		    FILE *cscFile = fopen(fnameBuf, "w");
		    GenCscFile(g, i, cscFile);
            fclose(cscFile);
        } else if (strcmp(suffix, "bin") == 0) {
		    FILE *cscFile = fopen(fnameBuf, "wb");
		    GenBinCscFile(g, i, cscFile);
            fclose(cscFile);
        } else {
            fprintf(stderr, "Unsupported file format: %s !\n", suffix);
            assert(false);
        }
	}


	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x2b5a
movq 0x54aa(%rip), %rax      # 0x7fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x258b(%rip), %rsi      # 0x50d2
movb $0x0, %al
callq 0x2200
movl $0x1, -0x4(%rbp)
jmp 0x2cbf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x259f(%rip), %rsi      # 0x5108
callq 0x21a0
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)
movq -0x18(%rbp), %rdi
callq 0x42e0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x7, -0x34(%rbp)
jge 0x2cb8
leaq -0x420(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %r8
leaq 0x2549(%rip), %rsi      # 0x510a
movb $0x0, %al
callq 0x2050
movq -0x28(%rbp), %rdi
leaq 0x253f(%rip), %rsi      # 0x5112
callq 0x21f0
cmpl $0x0, %eax
jne 0x2c1b
leaq -0x420(%rbp), %rdi
leaq 0x252b(%rip), %rsi      # 0x5116
callq 0x21a0
movq %rax, -0x428(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x428(%rbp), %rdx
callq 0x23d0
movq -0x428(%rbp), %rdi
callq 0x2120
jmp 0x2ca8
movq -0x28(%rbp), %rdi
leaq 0x24f2(%rip), %rsi      # 0x5118
callq 0x21f0
cmpl $0x0, %eax
jne 0x2c6b
leaq -0x420(%rbp), %rdi
leaq 0x24de(%rip), %rsi      # 0x511c
callq 0x21a0
movq %rax, -0x430(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x430(%rbp), %rdx
callq 0x2740
movq -0x430(%rbp), %rdi
callq 0x2120
jmp 0x2ca6
movq 0x536e(%rip), %rax      # 0x7fe0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x249f(%rip), %rsi      # 0x511f
movb $0x0, %al
callq 0x2200
leaq 0x24b0(%rip), %rdi      # 0x513e
leaq 0x239e(%rip), %rsi      # 0x5033
movl $0x87, %edx
leaq 0x24a3(%rip), %rcx      # 0x5144
callq 0x20c0
jmp 0x2ca8
jmp 0x2caa
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2b9e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopl (%rax,%rax)
// File: shijiajia[P]TinyMudo/./TcpConnection.h
// Function: TinyMuduo::TcpConnection::HandleEvent()
virtual void HandleEvent()
	{
		char buf[1024];
		memset(buf,0,sizeof(buf));
		int n=read(m_nConnFd,buf,1024);
		if (n<0)
		{
			std::cout<<"read error errno"<<errno<<std::endl;
			close(m_nConnFd);
		}else if (n==0)
		{
			std::cout<<"client close"<<std::endl;
			close(m_nConnFd);
		}else{
			if (write(m_nConnFd,buf,n)!=n)
				std::cout<<"write error errno:"<<errno<<std::endl;;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x20f0
movq -0x420(%rbp), %rax
movl 0xc(%rax), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x21a0
movl %eax, -0x414(%rbp)
cmpl $0x0, -0x414(%rbp)
jge 0x2747
movq 0x48da(%rip), %rdi      # 0x6fd8
leaq 0x1953(%rip), %rsi      # 0x4058
callq 0x2140
movq %rax, -0x428(%rbp)
callq 0x2030
movq -0x428(%rbp), %rdi
movl (%rax), %esi
callq 0x21e0
movq %rax, %rdi
movq 0x489a(%rip), %rsi      # 0x6fc8
callq 0x2170
movq -0x420(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x2230
jmp 0x27ec
cmpl $0x0, -0x414(%rbp)
jne 0x2783
movq 0x4881(%rip), %rdi      # 0x6fd8
leaq 0x190b(%rip), %rsi      # 0x4069
callq 0x2140
movq %rax, %rdi
movq 0x485b(%rip), %rsi      # 0x6fc8
callq 0x2170
movq -0x420(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x2230
jmp 0x27ea
movq -0x420(%rbp), %rax
movl 0xc(%rax), %edi
leaq -0x410(%rbp), %rsi
movslq -0x414(%rbp), %rdx
callq 0x2090
movslq -0x414(%rbp), %rcx
cmpq %rcx, %rax
je 0x27e8
movq 0x4825(%rip), %rdi      # 0x6fd8
leaq 0x18bc(%rip), %rsi      # 0x4076
callq 0x2140
movq %rax, -0x430(%rbp)
callq 0x2030
movq -0x430(%rbp), %rdi
movl (%rax), %esi
callq 0x21e0
movq %rax, %rdi
movq 0x47e5(%rip), %rsi      # 0x6fc8
callq 0x2170
jmp 0x27ea
jmp 0x27ec
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: shijiajia[P]TinyMudo/Acceptor.cpp
// Function: TinyMuduo::Acceptor::Start()
void Acceptor::Start()
{
	SocketAndBind();
	m_pChannel=new Channel(m_nEpollfd,m_nListenFd);
	m_pChannel->SetCallBack(this);
	m_pChannel->EableReading();
	if (listen(m_nListenFd,BACKLOG)<0) std::cout<<"listen failed: errno"<<errno<<std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x28e0
movl $0x18, %edi
callq 0x2150
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x20(%rbp)
movl 0x18(%rax), %esi
movl 0x28(%rax), %edx
callq 0x2670
jmp 0x283e
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, 0x30(%rsi)
movq 0x30(%rsi), %rdi
callq 0x2480
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x24a0
movq -0x28(%rbp), %rax
movl 0x28(%rax), %edi
movl $0x5, %esi
callq 0x2180
cmpl $0x0, %eax
jge 0x28ca
movq 0x475b(%rip), %rdi      # 0x6fd8
leaq 0x1805(%rip), %rsi      # 0x4089
callq 0x2140
movq %rax, -0x30(%rbp)
callq 0x2030
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x21e0
movq %rax, %rdi
movq 0x4721(%rip), %rsi      # 0x6fc8
callq 0x2170
jmp 0x28ca
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x18, %esi
callq 0x2160
jmp 0x28d0
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x21f0
nopl (%rax)