LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/List.cpp
// Function: List::put(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void List::put(size_t pos, const string& s)
{
    ListNode* newnode = new ListNode();
    newnode->s = s;
    if (pos > sz)
        pos = sz;
    if (pos == sz)
        push(s);
    else if (pos == 0) {
        head->prev = newnode;
        newnode->next = head;
        head = newnode;
    } else {
        ListNode* p = head;
        size_t i = 0;
        while (p->next != nullptr) {
            if (i != pos) {
                ++i;
                p = p->next;
            } else {
            	break;
			}
        }
        p->prev->next = newnode;
        newnode->prev = p->prev;
        p->prev = newnode;
        newnode->next = p;
    }
    newnode = nullptr;
    ++sz;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x30
popq %rdi
callq 0x3310
movq %rax, %r14
movq %rax, %rdi
callq 0x9c32
movq %r14, %rdi
movq %r15, %rsi
callq 0x31c0
movq 0x20(%rbx), %rax
movq %r12, %rcx
cmpq %r12, %rax
cmovbq %rax, %rcx
jbe 0x99c7
movq 0x28(%rbx), %rdx
testq %r12, %r12
je 0x99d8
movq %rdx, %rsi
movq 0x28(%rdx), %rdx
subq $0x1, %rcx
setb %dil
testq %rdx, %rdx
je 0x99b1
testb %dil, %dil
je 0x9998
movq 0x20(%rsi), %rcx
movq %r14, 0x28(%rcx)
movq %rcx, 0x20(%r14)
movq %r14, 0x20(%rsi)
movq %rsi, 0x28(%r14)
jmp 0x99e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9840
movq 0x20(%rbx), %rax
jmp 0x99e4
movq %r14, 0x20(%rdx)
movq %rdx, 0x28(%r14)
movq %r14, 0x28(%rbx)
incq %rax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x32e0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/List.cpp
// Function: List::get(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool List::get(const size_t pos, string& s)
{
    if (pos >= sz)
        return false;

    ListNode* p = head;
    size_t i = 0;
    while (p->next != nullptr) {
        if (i == pos) {
            s = p->s;
            break;
        } else {
            p = p->next;
            ++i;
        }
    }
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x20(%rdi), %r14
cmpq %rsi, %r14
jbe 0x9a3b
movq 0x28(%rdi), %rcx
leaq 0x1(%rbx), %rax
movq %rcx, %rsi
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
je 0x9a3b
decq %rax
jne 0x9a22
movq %rdx, %rdi
callq 0x31c0
cmpq %rbx, %r14
seta %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/List.cpp
// Function: List::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool List::del(const string& s)
{
    size_t pos;
    if ((pos = index(s)) != size_t(-1)) {
        if (pos == 0) {
            pop();
            return true;
        } else if (pos == sz-1) {
            if (sz == 1) {
                delete tail;
                head = tail = nullptr;
            } else {
                tail = tail->prev;
                delete tail->next;
                tail->next = nullptr;
            }
        } else {
            ListNode* p = head;
            while (p->next != nullptr) {
                if (p->s == s)
                    break;
                else
                	p = p->next;
            }
            p->prev->next = p->next;
            p->next->prev = p->prev;
            delete p;
        }
        --sz;
        return true;
    } else {
        return false;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x990a
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x9b49
testl %ebx, %ebx
je 0x9ab2
movslq %ebx, %rcx
movq 0x20(%r14), %rax
leaq -0x1(%rax), %rdx
cmpq %rcx, %rdx
jne 0x9acc
movq 0x30(%r14), %r15
cmpq $0x1, %rax
jne 0x9b1b
testq %r15, %r15
je 0x9a9d
movq %r15, %rdi
callq 0x8b62
movq %r15, %rdi
callq 0x32e0
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
jmp 0x9b45
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x98ae
movq %r15, %rdi
callq 0x8b62
jmp 0x9b49
leaq 0x28(%r14), %rbp
xorl %r13d, %r13d
movq (%rbp), %r12
cmpq $0x0, 0x28(%r12)
je 0x9af7
leaq 0x28(%r12), %rbp
movq %r12, %rdi
movq %r15, %rsi
callq 0x5682
testb %al, %al
je 0x9ad3
movq (%rbp), %r13
movq 0x20(%r12), %rax
movq %r13, 0x28(%rax)
movq 0x28(%r12), %rcx
movq %rax, 0x20(%rcx)
movq %r12, %rdi
callq 0x8b62
movq %r12, %rdi
callq 0x32e0
jmp 0x9b45
movq 0x20(%r15), %rax
movq %rax, 0x30(%r14)
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x9b34
movq %r15, %rdi
callq 0x8b62
movq %r15, %rdi
callq 0x32e0
movq 0x30(%r14), %rax
andq $0x0, 0x28(%rax)
decq 0x20(%r14)
cmpl $-0x1, %ebx
setne %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/List.cpp
// Function: List::print[abi:cxx11]()
string List::print()
{
    std::ostringstream os;
    ListNode* p = head;
    if (p == nullptr)
        os << "[]" << std::endl;

    os << "[";
    while (p != nullptr && p->next != nullptr) {
        os << p->s << ", ";
        p = p->next;
    }
    os << p->s << "]";
    return os.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x33a0
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x9b9a
leaq 0x1c27(%rip), %rsi      # 0xb7b1
movq %rsp, %rdi
callq 0x3300
movq %rax, %rdi
callq 0x3190
leaq 0x18ee(%rip), %rsi      # 0xb48f
movq %rsp, %rdi
callq 0x3300
movq %rsp, %r15
leaq 0x1b19(%rip), %r12      # 0xb6cc
testq %r14, %r14
je 0x9bdb
cmpq $0x0, 0x28(%r14)
je 0x9bdb
movq %r15, %rdi
movq %r14, %rsi
callq 0x32b0
movq %rax, %rdi
movq %r12, %rsi
callq 0x3300
movq 0x28(%r14), %r14
jmp 0x9bb3
movq %rsp, %rdi
movq %r14, %rsi
callq 0x32b0
leaq 0x1bc5(%rip), %rsi      # 0xb7b2
movq %rax, %rdi
callq 0x3300
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
movq %rsp, %rdi
callq 0x3090
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x9c1e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rowdyroad[P]dtmfdecoder/example.cpp
// Function: loadWaveFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, WAVHeader&)
FILE * loadWaveFile(const std::string& filename, WAVHeader& header)
{
  FILE * fd = fopen(filename.c_str(), "rb");
  if (fd == nullptr) {
    std::cout << "Wave file not found!" << std::endl;
    exit(1);
  }
  fread(&header, sizeof(WAVHeader), 1, fd);
  return fd;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rdi
leaq 0x1d23(%rip), %rsi      # 0x4090
callq 0x2190
testq %rax, %rax
je 0x2396
movq %rax, %r14
pushq $0x48
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x21c0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x4c3b(%rip), %rdi      # 0x6fd8
leaq 0x1cef(%rip), %rsi      # 0x4093
callq 0x2130
movq %rax, %rdi
callq 0x20a0
pushq $0x1
popq %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/rowdyroad[P]dtmfdecoder/example.cpp
// Function: main
int main (int argc, char *argv[])
{
  if (argc < 2) {
    std::cout << "Usage: " << argv[0] << " something.wav" << std::endl;
    return 1;
  }

  WAVHeader header;

  FILE * fp = loadWaveFile(argv[1], header);

  size_t timestamp = 0;
  size_t read_length = 0;

  std::vector<int16_t> frames(400);

  TextHandler handler;
  DTMFDecoder<> decoder(&handler);
  std::cout << "Detecting begin..." << std::endl;
  while (read_length < header.subchunk2Size) {
    int chunk_length = fread(frames.data(), sizeof(int16_t), frames.size(), fp);

    if (chunk_length <= 0) {
      break;
    }
    read_length += chunk_length * sizeof(int16_t);
    decoder.decode(frames, chunk_length);
  }

  fclose(fp);
  std::cout << "Detecting complete!" << std::endl;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rsi, %rbx
cmpl $0x1, %edi
jg 0x240f
movq 0x4bff(%rip), %rdi      # 0x6fd8
leaq 0x1cc8(%rip), %rsi      # 0x40a8
callq 0x2130
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x2130
leaq 0x1cb9(%rip), %rsi      # 0x40b0
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x20a0
pushq $0x1
popq %rax
jmp 0x255e
movl $0x46464952, 0x28(%rsp) # imm = 0x46464952
movabsq $0x20746d6645564157, %rax # imm = 0x20746D6645564157
movq %rax, 0x38(%rsp)
movq $0x10, 0x40(%rsp)
movw $0x1, 0x48(%rsp)
movl $0x61746164, 0x64(%rsp) # imm = 0x61746164
andq $0x0, 0x68(%rsp)
movq 0x8(%rbx), %rsi
leaq 0x70(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x25ac
leaq 0x70(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x235c
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rdx
movl $0x190, %esi            # imm = 0x190
callq 0x25e8
leaq 0x48ea(%rip), %rax      # 0x6d78
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x70(%rsp), %rdi
pushq $0x32
popq %rcx
pushq $0xa
popq %r8
movsd 0x1b5e(%rip), %xmm0     # 0x4008
movl $0x1f40, %edx           # imm = 0x1F40
callq 0x263a
movq 0x4b1d(%rip), %rdi      # 0x6fd8
leaq 0x1bfd(%rip), %rsi      # 0x40bf
callq 0x2130
movq %rax, %rdi
callq 0x20a0
movq 0x68(%rsp), %rbp
xorl %r15d, %r15d
pushq $0x2
popq %r14
leaq 0x8(%rsp), %r12
cmpq %rbp, %r15
jae 0x2525
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
subq %rdi, %rdx
sarq %rdx
movq %r14, %rsi
movq %rbx, %rcx
callq 0x21c0
movq %rax, %r13
testl %r13d, %r13d
jle 0x2525
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
leaq 0x70(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x27de
leaq (%r15,%r13,2), %r15
jmp 0x24e0
movq %rbx, %rdi
callq 0x2140
movq 0x4aa4(%rip), %rdi      # 0x6fd8
leaq 0x1b97(%rip), %rsi      # 0x40d2
callq 0x2130
movq %rax, %rdi
callq 0x20a0
leaq 0x70(%rsp), %rdi
callq 0x2a02
leaq 0x8(%rsp), %rdi
callq 0x2c94
xorl %eax, %eax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x259a
jmp 0x2586
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2090
jmp 0x25a4
movq %rax, %rbx
jmp 0x25a4
jmp 0x258d
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2a02
leaq 0x8(%rsp), %rdi
callq 0x2c94
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/rowdyroad[P]dtmfdecoder/./DTMFDecoder.h
// Function: DTMFDecoder<short>::DTMFDecoder(DTMFDecoder<short>::Handler*, unsigned long, unsigned long, unsigned long, double)
DTMFDecoder(Handler* handler, size_t sampleRate = 8000, size_t windowDurationMilliseconds = 50, size_t windowOverlapMilliseconds = 10, double thresold = -59.0)
        : handler_(handler)
        , sampleRate_(sampleRate)
        , windowDurationMilliseconds_(windowDurationMilliseconds)
        , thresold_(thresold)
      {
          if (windowOverlapMilliseconds > windowDurationMilliseconds_) {
            windowOverlapMilliseconds = windowDurationMilliseconds_;
          }
          samplesPerMilliseconds_ = sampleRate_ / 1000;
          framesCount_ = samplesPerMilliseconds_* windowDurationMilliseconds_;
          overlapFramesCount_ = samplesPerMilliseconds_ * windowOverlapMilliseconds;
          windowFrames_.reserve(framesCount_);

          createWindowFunctionTable();
          reset();
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x10(%rsp)
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
andw $0x0, (%rdi)
addq $0x8, %rdi
movabsq $0x3ad0354030202b9, %rax # imm = 0x3AD0354030202B9
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
pushq $0x4
popq %rbp
leaq 0x7(%rsp), %rcx
movq %rdi, 0x18(%rsp)
movq %r14, %rsi
movq %rbp, %rdx
callq 0x2d6a
leaq 0x20(%r15), %rcx
movabsq $0x66105c5053804b9, %rax # imm = 0x66105C5053804B9
movq %rax, (%r14)
movq %rcx, %r14
leaq 0x20(%rsp), %rsi
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
movq %rbp, %rdx
callq 0x2d6a
movaps 0x198f(%rip), %xmm0     # 0x4050
movups %xmm0, 0x38(%r15)
movq 0x8(%rsp), %rax
movq %rax, 0x48(%r15)
movq %rbx, 0x50(%r15)
movq %r12, 0x60(%r15)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x80(%r15)
leaq 0x88(%r15), %rbp
andl $0x0, 0xc0(%r15)
leaq 0xa0(%r15), %rax
movq %rax, 0x10(%rsp)
andq $0x0, 0xc8(%r15)
leaq 0xb8(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0xc0(%r15), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r15)
movups %xmm0, 0x98(%r15)
movups %xmm0, 0xa8(%r15)
movq %rax, 0xd0(%r15)
movq %rax, 0xd8(%r15)
andq $0x0, 0xe0(%r15)
cmpq %r13, %r12
cmovbq %r12, %r13
movl $0x3e8, %ecx            # imm = 0x3E8
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0x58(%r15)
imulq %rax, %r12
movq %r12, 0x68(%r15)
imulq %rax, %r13
movq %r13, 0x70(%r15)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2da0
movq %r15, %rdi
callq 0x2e34
movq %r15, %rdi
callq 0x2f52
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x27cb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x2b0a
movq 0x10(%rsp), %rdi
callq 0x2b6c
movq %rbp, %rdi
callq 0x2c94
movq %r14, %rdi
callq 0x2ba0
movq 0x18(%rsp), %rdi
callq 0x2ba0
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/rowdyroad[P]dtmfdecoder/./DTMFDecoder.h
// Function: DTMFDecoder<short>::createWindowFunctionTable()
void createWindowFunctionTable()
      {
          windowFunctionTable_.resize(framesCount_);
          for (size_t i = 0; i < framesCount_; ++i) {
            windowFunctionTable_[i] = (0.42 - 0.5 * cos(2.0 * M_PI * i / (framesCount_ - 1)) + 0.08 * cos(4.0 * M_PI * i / (framesCount_ - 1)))
                                      /
                                      (pow(2, sizeof(T) * 8 - 1) - 1);
          }
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0xa0, %rdi
movq 0x68(%rbx), %rsi
callq 0x3028
xorl %r14d, %r14d
movq 0x68(%rbx), %rax
cmpq %rax, %r14
jae 0x2f4a
movq %r14, %xmm0
movq 0x11f5(%rip), %xmm1     # 0x4060
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movdqa %xmm1, %xmm2
movapd 0x11f5(%rip), %xmm1     # 0x4070
subpd %xmm1, %xmm0
movapd %xmm1, %xmm3
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
mulsd 0x116f(%rip), %xmm0     # 0x4010
decq %rax
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x2220
mulsd 0x114a(%rip), %xmm0     # 0x4018
addsd 0x114a(%rip), %xmm0     # 0x4020
movsd %xmm0, 0x8(%rsp)
movapd 0x10(%rsp), %xmm2
mulsd 0x113e(%rip), %xmm2     # 0x4028
movq 0x68(%rbx), %rax
decq %rax
movq %rax, %xmm0
punpckldq 0x1162(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x116a(%rip), %xmm0     # 0x4070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
callq 0x2220
mulsd 0x1109(%rip), %xmm0     # 0x4030
addsd 0x8(%rsp), %xmm0
divsd 0x1103(%rip), %xmm0     # 0x4038
movq 0xa0(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x2e51
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/rowdyroad[P]dtmfdecoder/./DTMFDecoder.h
// Function: DTMFDecoder<short>::fillDtmfStatsTable()
void fillDtmfStatsTable()
      {
        dtmfStatsTable_.clear();
        size_t idxl = 0;
        for (auto l : kLowFreqs_) {
          size_t idxh = 0;
          for (auto h : kHighFreqs_) {
            uint8_t c = kDtmfCodes_[idxl][idxh];
            dtmfStatsTable_.insert(std::make_pair(std::make_pair(l,h), FrequencyPairStat({0, c})));
            ++idxh;
          }
          ++idxl;
        }
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0xb8(%rdi), %r14
movq %r14, %rdi
callq 0x32c8
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rsp)
movq %rbx, (%rsp)
leaq 0x38(%rbx), %r12
leaq 0x20(%rsp), %r15
cmpq 0x8(%rsp), %rax
je 0x32b9
movq %rax, 0x18(%rsp)
movzwl (%rax), %r13d
movq (%rsp), %rax
movq 0x20(%rax), %rbx
movq 0x28(%rax), %rbp
movq %r12, 0x10(%rsp)
cmpq %rbp, %rbx
je 0x32a5
movb (%r12), %al
movzwl (%rbx), %ecx
shll $0x10, %ecx
orl %r13d, %ecx
movl %ecx, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movb %al, 0x30(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x32f6
addq $0x2, %rbx
incq %r12
jmp 0x3271
movq 0x18(%rsp), %rax
addq $0x2, %rax
movq 0x10(%rsp), %r12
addq $0x4, %r12
jmp 0x3250
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rowdyroad[P]dtmfdecoder/./DTMFDecoder.h
// Function: DTMFDecoder<short>::getExistsFrequency(std::vector<double, std::allocator<double>> const&, std::vector<unsigned short, std::allocator<unsigned short>> const&)
Frequency getExistsFrequency(const std::vector<double>& frames, const std::vector<Frequency>& frequencies)
      {
        double max = thresold_;
        Frequency ret = kUndefinedFrequency;
        for (auto f : frequencies) {
          double mag = 20.0 * log10(goertzelFunction(f , frames));
          if (mag > max) {
            max = mag;
            ret = f;
          }
        }
        return ret;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x80(%rdi), %xmm0
movzwl (%rdi), %ebp
movq (%rdx), %r12
movq 0x8(%rdx), %r13
cmpq %r13, %r12
je 0x35ad
movzwl (%r12), %r15d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movsd %xmm0, (%rsp)
callq 0x3886
callq 0x20b0
mulsd 0xaad(%rip), %xmm0      # 0x4040
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
cmovbel %ebp, %r15d
maxsd %xmm1, %xmm0
addq $0x2, %r12
movl %r15d, %ebp
jmp 0x3569
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rowdyroad[P]dtmfdecoder/./DTMFDecoder.h
// Function: DTMFDecoder<short>::truncateDtmfStatTable(std::pair<unsigned short, unsigned short> const*)
void truncateDtmfStatTable(const FrequencyPair* ignore_pair = nullptr)
      {
        for (auto& kv : dtmfStatsTable_) {
          if (ignore_pair && kv.first == *ignore_pair) continue;
          if (kv.second.duration >= framesCount_) {
            handler_->OnCodeEnd(this,kv.second.code, kv.second.duration);
          }
          kv.second.duration = 0;
        }
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xd0(%rdi), %r15
leaq 0xc0(%rdi), %r12
cmpq %r12, %r15
je 0x3633
testq %rbx, %rbx
je 0x3605
movd 0x20(%r15), %xmm0
movd (%rbx), %xmm1
pcmpeqw %xmm0, %xmm1
pshuflw $0x50, %xmm1, %xmm0     # xmm0 = xmm1[0,0,1,1,4,5,6,7]
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
movmskpd %xmm0, %eax
cmpl $0x3, %eax
je 0x3626
movq 0x28(%r15), %rcx
cmpq 0x68(%r14), %rcx
jb 0x3621
movq 0x48(%r14), %rdi
movzbl 0x30(%r15), %edx
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
andq $0x0, 0x28(%r15)
movq %r15, %rdi
callq 0x20e0
movq %rax, %r15
jmp 0x35da
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rowdyroad[P]dtmfdecoder/./DTMFDecoder.h
// Function: DTMFDecoder<short>::goertzelFunction(unsigned long, std::vector<double, std::allocator<double>> const&)
double goertzelFunction(size_t frequency, const std::vector<double>& samples)
      {
          size_t scalingFactor = samples.size() / 2;
          double k = 0.5 + (((double)samples.size() * frequency) / sampleRate_),
                 omega = (2.0 * M_PI * k) / samples.size(),
                 sine = sin(omega),
                 cosine =cos(omega),
                 coeff = 2.0 * cosine,
                 q0 = 0,
                 q1 = 0,
                 q2 = 0;

          for (auto sample : samples) {
              q0 = coeff * q1 - q2 + sample;
              q2 = q1;
              q1 = q0;
          }
          double real = (q1 - q2 * cosine) / scalingFactor;
          double imag = (q2 * sine) / scalingFactor;
          return sqrtf(real*real + imag*imag);
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq 0x8(%rdx), %r14
subq (%rdx), %r14
sarq $0x3, %r14
movq %r14, %xmm0
movq 0x7b8(%rip), %xmm1      # 0x4060
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x7bc(%rip), %xmm2      # 0x4070
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movq %rsi, %xmm4
punpckldq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
subpd %xmm2, %xmm4
movapd %xmm4, %xmm0
unpckhpd %xmm4, %xmm0            # xmm0 = xmm0[1],xmm4[1]
addsd %xmm4, %xmm0
mulsd %xmm3, %xmm0
movq 0x50(%rdi), %xmm4
punpckldq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
subpd %xmm2, %xmm4
movapd %xmm4, %xmm1
unpckhpd %xmm4, %xmm1            # xmm1 = xmm1[1],xmm4[1]
addsd %xmm4, %xmm1
divsd %xmm1, %xmm0
addsd 0x742(%rip), %xmm0      # 0x4048
mulsd 0x702(%rip), %xmm0      # 0x4010
divsd %xmm3, %xmm0
movapd %xmm0, 0x10(%rsp)
callq 0x2040
movsd %xmm0, 0x8(%rsp)
movapd 0x10(%rsp), %xmm0
callq 0x2220
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
xorpd %xmm4, %xmm4
movapd 0x737(%rip), %xmm5      # 0x4080
xorpd %xmm3, %xmm3
movapd %xmm4, %xmm2
xorpd %xmm5, %xmm2
cmpq %rcx, %rax
je 0x3978
movapd %xmm1, %xmm6
mulsd %xmm3, %xmm6
addsd %xmm2, %xmm6
addsd (%rax), %xmm6
addq $0x8, %rax
movapd %xmm3, %xmm4
movapd %xmm6, %xmm3
jmp 0x394d
shrq %r14
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
cvtsi2sd %r14, %xmm0
divsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm1
mulsd %xmm4, %xmm1
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
cvtsd2ss %xmm2, %xmm0
sqrtss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/src/main.cpp
// Function: main
int main(int argc, char** argv)
{
    /* set the RV data file */
    datafile = "examples/BL2009/BL2009_dataset1.kms.rv";

    /* load the file (RVs are in km/s) */
    /* don't skip any lines in the header */
    Data::get_instance().load(datafile, "kms", 0);

    // set the sampler and run it!
    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x710, %rsp            # imm = 0x710
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x4390d(%rip), %r14     # 0x646c8
leaq 0x263eb(%rip), %rsi     # 0x471ad
movq %r14, %rdi
callq 0x6770
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x6550
leaq 0x1b432(%rip), %rsi     # 0x3c210
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x13fac
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r8
movaps %xmm0, (%r8)
andq $0x0, 0x10(%r8)
leaq 0x4377b(%rip), %rdi     # 0x64580
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
xorl %ecx, %ecx
callq 0x7f8e
leaq 0x50(%rsp), %rdi
callq 0x9e7e
leaq 0x10(%rsp), %rdi
callq 0x6798
leaq 0x30(%rsp), %rdi
callq 0x6798
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x21087
pushq $0x32
popq %rsi
movq %r14, %rdi
callq 0x210d4
leaq 0x50(%rsp), %rdi
callq 0x2129a
xorl %eax, %eax
addq $0x710, %rsp            # imm = 0x710
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2129a
jmp 0x20e9e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x9e7e
leaq 0x10(%rsp), %rdi
callq 0x6798
jmp 0x20e94
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6798
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/mshcompare/mshcompare.cpp
// Function: ReadMesh(char*)
static R3Mesh *
ReadMesh(char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate mesh
  R3Mesh *mesh = new R3Mesh();
  if (!mesh) {
    RNFail("Unable to allocate mesh for %s\n", filename);
    return NULL;
  }

  // Read mesh from file
  if (!mesh->ReadFile(filename)) {
    delete mesh;
    return NULL;
  }

  // Print statistics
  if (print_verbose) {
    printf("Read mesh from %s\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return success
  return mesh;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4f816
movq %rbx, %rdi
callq 0xee08
movl $0x138, %edi            # imm = 0x138
callq 0xc3a0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1f7e4
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x180(%rax)
testl %eax, %eax
je 0xedd9
cmpb $0x1, 0x6bd56(%rip)     # 0x7aac0
jne 0xede4
leaq 0x43302(%rip), %rdi     # 0x52075
movq %r14, %rsi
xorl %eax, %eax
callq 0xc070
leaq 0x8(%rsp), %rdi
callq 0x4f850
leaq 0x432fa(%rip), %rdi     # 0x52088
movb $0x1, %al
callq 0xc070
movl 0x34(%rbx), %esi
leaq 0x43300(%rip), %rdi     # 0x5209f
xorl %eax, %eax
callq 0xc070
movl 0x24(%rbx), %esi
leaq 0x432ff(%rip), %rdi     # 0x520af
xorl %eax, %eax
callq 0xc070
movl 0x14(%rbx), %esi
leaq 0x432fe(%rip), %rdi     # 0x520bf
xorl %eax, %eax
callq 0xc070
movq 0x6b1c9(%rip), %rax     # 0x79f98
movq (%rax), %rdi
callq 0xc460
jmp 0xede4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x138, %esi            # imm = 0x138
movq %rbx, %rdi
callq 0xc3b0
movq %r14, %rdi
callq 0xc670
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/useBlob2.cc
// Function: main
int main(int argc, char const *argv[])
{
	string str;
	StrBlob blob;
	ifstream data("./data/storyDataFile");

	while (getline(data, str))
		blob.push_back(str);

	for (StrBlobPtr it= blob.begin(); neq(it, blob.end()); it.incr())
		cout << it.deref() << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x25db
leaq 0xcb4(%rip), %rsi       # 0x3004
leaq -0x290(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x21d0
leaq -0x290(%rbp), %rbx
leaq -0x88(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2394
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2830
jmp 0x236d
leaq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2492
leaq -0x68(%rbp), %r14
leaq -0x38(%rbp), %r15
leaq -0x50(%rbp), %r12
movq 0x2c0c(%rip), %r13      # 0x4fc0
movq %r14, %rdi
movq %r15, %rsi
callq 0x24bc
movq %r12, %rdi
movq %r14, %rsi
callq 0x24af
movl %eax, %ebx
leaq -0x60(%rbp), %rdi
callq 0x2c28
testb %bl, %bl
je 0x23fe
movq %r12, %rdi
callq 0x24e6
movq %r13, %rdi
movq %rax, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x20b0
movq %r12, %rdi
callq 0x2566
jmp 0x23b4
leaq -0x48(%rbp), %rdi
callq 0x2c28
leaq -0x290(%rbp), %rdi
callq 0x2040
leaq -0x30(%rbp), %rdi
callq 0x2b98
leaq -0x88(%rbp), %rdi
callq 0x20a0
xorl %eax, %eax
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2458
movq %rax, %r14
jmp 0x2475
movq %rax, %r14
jmp 0x247e
jmp 0x245d
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x2c28
jmp 0x2460
movq %rax, %r14
jmp 0x2469
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2c28
leaq -0x290(%rbp), %rdi
callq 0x2040
leaq -0x30(%rbp), %rdi
callq 0x2b98
leaq -0x88(%rbp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/vividvilla[P]hackerrank/src/quicksort1.cpp
// Function: partition(std::vector<int, std::allocator<int>>)
vector<int> partition(vector<int> ar) {
    int N = ar.size();

    int p = ar[0];
    vector<int> p1;
    vector<int> p2;
    for (int i = 0; i < N; i++) {
        if (ar[i] < p)
            p1.push_back(ar[i]);
        else if (ar[i] > p)
            p2.push_back(ar[i]);
    }
    p1.push_back(p);
    p1.insert(p1.end(), p2.begin(), p2.end());

    return p1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %r15
subq %rax, %r15
shrq $0x2, %r15
movl (%rax), %ebp
movl %ebp, 0xc(%rsp)
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rsp), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
shlq $0x2, %r15
cmpq %r13, %r15
je 0x12c1
movq (%r14), %rsi
movq %rbx, %rdi
cmpl %ebp, (%rsi,%r13)
jl 0x12b3
movq %r12, %rdi
jle 0x12bb
addq %r13, %rsi
callq 0x1440
addq $0x4, %r13
jmp 0x129d
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x1440
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x145e
leaq 0x10(%rsp), %rdi
callq 0x14d6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1304
jmp 0x1304
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x14d6
movq %rbx, %rdi
callq 0x14d6
movq %r14, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/vividvilla[P]hackerrank/src/quicksort1.cpp
// Function: main
int main() {
    int n, x;
    cin >> n;

    vector<int> ar;
    for (int i = 0; i < n; i++) {
        cin >> x;
        ar.push_back(x);
    }

    vector<int> p = partition(ar);
    for (int i = 0; i < n; i++) {
        cout << p[i];
        if (i + 1 < n)
            cout << " ";
        else
            cout << endl;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0x2cae(%rip), %rbx      # 0x3fe0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1080
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
xorl %ebp, %ebp
leaq 0xc(%rsp), %r15
cmpl 0x8(%rsp), %ebp
jge 0x1377
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1080
movq %r14, %rdi
movq %r15, %rsi
callq 0x1440
incl %ebp
jmp 0x1357
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x147e
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x124c
leaq 0x28(%rsp), %rdi
callq 0x14d6
xorl %r15d, %r15d
movq 0x2c27(%rip), %rbx      # 0x3fd0
leaq 0xc54(%rip), %r14       # 0x2004
movslq 0x8(%rsp), %rax
cmpq %rax, %r15
jge 0x13ef
movq 0x40(%rsp), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x1100
leal 0x1(%r15), %eax
cmpl %eax, 0x8(%rsp)
jle 0x13e2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10b0
jmp 0x13ea
movq %rbx, %rdi
callq 0x1060
incq %r15
jmp 0x13b0
leaq 0x40(%rsp), %rdi
callq 0x14d6
leaq 0x10(%rsp), %rdi
callq 0x14d6
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x1424
jmp 0x142b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x14d6
jmp 0x142e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x14d6
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/ashlall[P]StreamStats/ChiSquareExperiments/VaryMemoryReal.cpp
// Function: name_file(char*, char**, int)
void name_file(char *str, char* argv[], int extra)
{
  time_t now = time(0);
  struct tm tstruct;
  char buf[80];
  tstruct = *localtime(&now);
  strftime(buf, sizeof(buf), "%m-%d-%Y.%X", &tstruct);

  strcpy(str, "RealContinuous_");
  strcat(str, argv[1]);
  strcat(str, "-");
  strcat(str, argv[2]);
  strcat(str, "_");
  strcat(str, argv[3]);
  strcat(str, "_");
  strcat(str, argv[5]);
  strcat(str, "_");
  strcat(str, buf);

  if (extra == 0)
  strcat(str, "_log.dat");
 else if (extra == 1)
   strcat(str, "_table.dat");
 else if (extra == 2)
   strcat(str, "_extra.dat");
 else 
   strcat(str, "_pvalues.dat");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
xorl %edi, %edi
callq 0x21c0
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
callq 0x2160
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq -0x70(%rbp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rcx)
leaq 0x331a(%rip), %rdx      # 0x839a
leaq -0xc0(%rbp), %r12
pushq $0x50
popq %rsi
movq %r12, %rdi
callq 0x21a0
movups 0x330d(%rip), %xmm0     # 0x83a6
movups %xmm0, (%r14)
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x2350
movq %r14, %rdi
callq 0x20e0
movw $0x2d, (%r14,%rax)
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x2350
movq %r14, %rdi
callq 0x20e0
movw $0x5f, %r13w
movw %r13w, (%r14,%rax)
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x2350
movq %r14, %rdi
callq 0x20e0
movw %r13w, (%r14,%rax)
movq 0x28(%r15), %rsi
movq %r14, %rdi
callq 0x2350
movq %r14, %rdi
callq 0x20e0
movw %r13w, (%r14,%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x2350
movq %r14, %rdi
callq 0x20e0
addq %r14, %rax
cmpl $0x2, %ebx
je 0x514b
cmpl $0x1, %ebx
je 0x513f
testl %ebx, %ebx
jne 0x5161
movabsq $0x7461642e676f6c5f, %rcx # imm = 0x7461642E676F6C5F
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
jmp 0x517c
movabsq $0x642e656c6261745f, %rcx # imm = 0x642E656C6261745F
jmp 0x5155
movabsq $0x642e61727478655f, %rcx # imm = 0x642E61727478655F
movq %rcx, (%rax)
movl $0x746164, 0x7(%rax)    # imm = 0x746164
jmp 0x517c
movabsq $0x7461642e736575, %rcx # imm = 0x7461642E736575
movq %rcx, 0x5(%rax)
movabsq $0x7365756c6176705f, %rcx # imm = 0x7365756C6176705F
movq %rcx, (%rax)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bluesky466[P]ResourcesParser/main.cpp
// Function: main
int main(int argc, char *argv[]) {
	const char* path = getArgv("-p", argv, argc);
	const char* type = getArgv("-t", argv, argc);
	const char* id = getArgv("-i", argv, argc);
	int all = findArgvIndex("-a", argv, argc);

	if(nullptr == path) {
		printHelp();
		return -1;
	} else if(getArgv("-h", argv, argc) != nullptr) {
		printHelp();
	}

	ResourcesParser parser(path);
	ResourcesParserInterpreter interpreter(&parser);

	if(all >= 0) {
		interpreter.parserResource(ResourcesParserInterpreter::ALL_TYPE);
	}

	if(type) {
		interpreter.parserResource(type);
	}

	if(id) {
		interpreter.parserId(id);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movl %edi, %r13d
leaq 0x6897(%rip), %rdi      # 0xa004
movl %r13d, %edx
callq 0x38e4
movq %rax, %r15
leaq 0x6888(%rip), %rdi      # 0xa007
movq %rbx, %rsi
movl %r13d, %edx
callq 0x38e4
movq %rax, %r14
leaq 0x6876(%rip), %rdi      # 0xa00a
movq %rbx, %rsi
movl %r13d, %edx
callq 0x38e4
movq %rax, -0x60(%rbp)
leaq 0x6863(%rip), %rdi      # 0xa00d
movq %rbx, %rsi
movl %r13d, %edx
callq 0x3910
testq %r15, %r15
je 0x388c
movl %eax, %r12d
leaq 0x6848(%rip), %rdi      # 0xa010
movq %rbx, %rsi
movl %r13d, %edx
callq 0x38e4
testq %rax, %rax
je 0x37dd
callq 0x3962
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movq %r15, %rsi
callq 0x3090
leaq -0xf8(%rbp), %rbx
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x56e6
leaq -0x58(%rbp), %rdi
callq 0x3378
movq %rbx, -0x38(%rbp)
testl %r12d, %r12d
js 0x3822
leaq 0xb9c7(%rip), %rsi      # 0xf1e0
leaq -0x38(%rbp), %rdi
callq 0x3bec
testq %r14, %r14
movq -0x60(%rbp), %rbx
je 0x3851
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r14, %rsi
callq 0x3090
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3bec
leaq -0x58(%rbp), %rdi
callq 0x3378
testq %rbx, %rbx
je 0x387c
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rbx, %rsi
callq 0x3090
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4516
leaq -0x58(%rbp), %rdi
callq 0x3378
leaq -0xf8(%rbp), %rdi
callq 0x39f0
xorl %eax, %eax
jmp 0x3894
callq 0x3962
pushq $-0x1
popq %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38aa
jmp 0x38ba
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3378
jmp 0x38bd
jmp 0x38ba
movq %rax, %rbx
leaq -0xf8(%rbp), %rdi
callq 0x39f0
jmp 0x38dc
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3378
jmp 0x38dc
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3340
// File: /workspace/github_cpp_makefile_star2_O2/bluesky466[P]ResourcesParser/main.cpp
// Function: getArgv(char const*, char**, int)
const char* getArgv(const char* argv, char *argvs[], int count) {
	int index = findArgvIndex(argv, argvs, count);
	if(index>=0 && index+1 < count) {
		return argvs[index+1];
	}
	return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
callq 0x3910
testl %eax, %eax
js 0x3909
incl %eax
cmpl %r14d, %eax
jge 0x3909
movl %eax, %eax
movq (%rbx,%rax,8), %rax
jmp 0x390b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bluesky466[P]ResourcesParser/main.cpp
// Function: findArgvIndex(char const*, char**, int)
int findArgvIndex(const char* argv, char *argvs[], int count) {
	for(int i = 0 ; i<count ; i++) {
		if(strcmp(argv, argvs[i])==0) {
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
testl %edx, %edx
cmovlel %r13d, %ebx
pushq $-0x1
popq %r12
cmpq %r13, %rbx
je 0x3950
movq (%r14,%r13,8), %rsi
movq %r15, %rdi
callq 0x3290
testl %eax, %eax
je 0x394d
incq %r13
jmp 0x3933
movl %r13d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bluesky466[P]ResourcesParser/main.cpp
// Function: printHelp()
void printHelp() {
	cout <<"rp -p path [-a] [-t type] [-i id]" <<endl<<endl;
	cout <<"-p : set path of resources.arsc" <<endl;
	cout <<"-a : show all of resources.arsc" <<endl;
	cout <<"-t : select the type in resources.arsc to show" <<endl;
	cout <<"-i : select the id of resource to show" <<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xb669(%rip), %rbx      # 0xefd8
leaq 0x669d(%rip), %rsi      # 0xa013
movq %rbx, %rdi
callq 0x31e0
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
leaq 0x66a0(%rip), %rsi      # 0xa035
movq %rbx, %rdi
callq 0x31e0
movq %rax, %rdi
callq 0x30d0
leaq 0x66a9(%rip), %rsi      # 0xa055
movq %rbx, %rdi
callq 0x31e0
movq %rax, %rdi
callq 0x30d0
leaq 0x66b2(%rip), %rsi      # 0xa075
movq %rbx, %rdi
callq 0x31e0
movq %rax, %rdi
callq 0x30d0
leaq 0x66ca(%rip), %rsi      # 0xa0a4
movq %rbx, %rdi
callq 0x31e0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30d0
// File: /workspace/github_cpp_makefile_star2_O2/bluesky466[P]ResourcesParser/ResourcesParserInterpreter.cpp
// Function: ResourcesParserInterpreter::parserResource(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ResourcesParserInterpreter::parserResource(const string& type) {
	for(auto it : mParser->getResourceForPackageName()) {
		cout<<it.first<<endl;
		ResourcesParser::ResStringPoolPtr types = it.second->pTypes;
		for(uint32_t i = 0 ; i < types->header.stringCount ; i++) {
			string resType = ResourcesParser::getStringFromResStringPool(types, i);
			if(type==ALL_TYPE || type == resType){
				parserResource(it.second, ID(i), resType, "\t");
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r15
movq %rdi, -0x58(%rbp)
movq (%rdi), %rcx
movq 0x38(%rcx), %rax
addq $0x28, %rcx
movq %rcx, -0x48(%rbp)
leaq -0xa8(%rbp), %r14
leaq -0xe8(%rbp), %r13
leaq -0xc8(%rbp), %r12
cmpq -0x48(%rbp), %rax
je 0x3d55
movq %rax, -0x50(%rbp)
leaq 0x20(%rax), %rsi
movq %r14, %rdi
callq 0x4836
movq 0xb38c(%rip), %rdi      # 0xefd8
movq %r14, %rsi
callq 0x31b0
movq %rax, %rdi
callq 0x30d0
movq -0x88(%rbp), %rsi
movl $0x120, %eax            # imm = 0x120
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x49cc
xorl %r14d, %r14d
movq -0x40(%rbp), %rax
cmpl 0x8(%rax), %r14d
jae 0x3d2f
leaq -0x78(%rbp), %rbx
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
callq 0x49cc
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x5dde
leaq -0x70(%rbp), %rdi
callq 0x3ac4
movq %r15, %rdi
leaq 0xb52a(%rip), %rsi      # 0xf1e0
callq 0x485f
testb %al, %al
jne 0x3cce
movq %r15, %rdi
movq %r13, %rsi
callq 0x485f
testb %al, %al
je 0x3d1f
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
leaq -0x88(%rbp), %rsi
callq 0x4a0a
movq %r12, %rdi
leaq 0x6439(%rip), %rsi      # 0xa124
leaq -0x29(%rbp), %rdx
callq 0x3090
incl %r14d
movq -0x58(%rbp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
movq %r13, %rcx
movq %r12, %r8
callq 0x3dc0
movq %r12, %rdi
callq 0x3378
leaq -0x60(%rbp), %rdi
callq 0x3ac4
jmp 0x3d22
incl %r14d
movq %r13, %rdi
callq 0x3378
jmp 0x3c77
leaq -0x38(%rbp), %rdi
callq 0x3ac4
leaq -0xa8(%rbp), %r14
movq %r14, %rdi
callq 0x3bcc
movq -0x50(%rbp), %rdi
callq 0x3210
jmp 0x3c2b
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3dac
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x3378
jmp 0x3d80
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3ac4
leaq -0xe8(%rbp), %rdi
callq 0x3378
jmp 0x3da3
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x3ac4
leaq -0x38(%rbp), %rdi
callq 0x3ac4
leaq -0xa8(%rbp), %rdi
callq 0x3bcc
movq %rbx, %rdi
callq 0x3340
// File: /workspace/github_cpp_makefile_star2_O2/bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: stringOfComplex[abi:cxx11](unsigned int, bool)
static string stringOfComplex(uint32_t complex, bool isFraction) {
	stringstream ss;
    const float MANTISSA_MULT =
        1.0f / (1<<Res_value::COMPLEX_MANTISSA_SHIFT);
    const float RADIX_MULTS[] = {
        1.0f*MANTISSA_MULT, 1.0f/(1<<7)*MANTISSA_MULT,
        1.0f/(1<<15)*MANTISSA_MULT, 1.0f/(1<<23)*MANTISSA_MULT
    };

    float value = (complex&(Res_value::COMPLEX_MANTISSA_MASK
                   <<Res_value::COMPLEX_MANTISSA_SHIFT))
            * RADIX_MULTS[(complex>>Res_value::COMPLEX_RADIX_SHIFT)
                            & Res_value::COMPLEX_RADIX_MASK];
	ss<<value;

    if (!isFraction) {
        switch ((complex>>Res_value::COMPLEX_UNIT_SHIFT)&Res_value::COMPLEX_UNIT_MASK) {
            case Res_value::COMPLEX_UNIT_PX: ss<<"px"; break;
            case Res_value::COMPLEX_UNIT_DIP: ss<<"dp"; break;
            case Res_value::COMPLEX_UNIT_SP: ss<<"sp"; break;
            case Res_value::COMPLEX_UNIT_PT: ss<<"pt"; break;
            case Res_value::COMPLEX_UNIT_IN: ss<<"in"; break;
            case Res_value::COMPLEX_UNIT_MM: ss<<"mm"; break;
            default: ss<<" (unknown unit)"; break;
        }
    } else {
        switch ((complex>>Res_value::COMPLEX_UNIT_SHIFT)&Res_value::COMPLEX_UNIT_MASK) {
            case Res_value::COMPLEX_UNIT_FRACTION: ss<<"%"; break;
            case Res_value::COMPLEX_UNIT_FRACTION_PARENT: ss<<"%p"; break;
            default: ss<<" (unknown unit)"; break;
        }
    }
	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x3120
movl %r15d, %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
cvtsi2ss %rax, %xmm0
movl %r15d, %eax
shrl $0x2, %eax
andl $0xc, %eax
leaq 0x4e0a(%rip), %rcx      # 0xa440
mulss (%rax,%rcx), %xmm0
leaq -0x198(%rbp), %r14
movq %r14, %rdi
callq 0x3140
andl $0xf, %r15d
testb %r12b, %r12b
je 0x5679
cmpl $0x1, %r15d
leaq 0x4d5e(%rip), %rax      # 0xa3bc
leaq 0x4d45(%rip), %rcx      # 0xa3aa
cmoveq %rax, %rcx
testl %r15d, %r15d
leaq 0x4d47(%rip), %rsi      # 0xa3ba
cmovneq %rcx, %rsi
jmp 0x5699
cmpl $0x6, %r15d
jae 0x5692
movl %r15d, %eax
leaq 0x4b37(%rip), %rcx      # 0xa1c0
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x5699
leaq 0x4d11(%rip), %rsi      # 0xa3aa
movq %r14, %rdi
callq 0x31e0
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x32d0
leaq -0x1a8(%rbp), %rdi
callq 0x3150
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x3340
// File: /workspace/github_cpp_makefile_star2_O2/bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: ResourcesParser::ResourcesParser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ResourcesParser::ResourcesParser(const string& filePath) {
	ifstream resources(filePath, ios::in|ios::binary);

	// resources文件开头是个ResTable_header,记录整个文件的信息
	resources.read((char*)&mResourcesInfo, sizeof(ResTable_header));

	// 紧接着就是全局字符串池
	mGlobalStringPool = parserResStringPool(resources);
	if(mGlobalStringPool == nullptr) {
		return;
	}

	for(int i = 0 ; i < mResourcesInfo.packageCount ; i++) {
		PackageResourcePtr pResource = parserPackageResource(resources);
		if(pResource == nullptr) {
			return;
		}
		mResourceForId[pResource->header.id] = pResource;
		mResourceForPackageName[toUtf8((char16_t*)pResource->header.name)] = pResource;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, -0x38(%rbp)
leaq 0x28(%rdi), %rax
andl $0x0, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
leaq 0x50(%rdi), %rax
movq %rax, -0x40(%rbp)
andl $0x0, 0x58(%rdi)
leaq 0x58(%rdi), %rax
andq $0x0, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
movups %xmm0, 0x88(%rdi)
leaq -0x298(%rbp), %rdi
pushq $0xc
popq %rdx
callq 0x32e0
leaq -0x298(%rbp), %rdi
pushq $0xc
popq %rdx
movq %rbx, %rsi
callq 0x3230
leaq -0x70(%rbp), %rdi
leaq -0x298(%rbp), %rdx
callq 0x58e8
leaq 0x10(%rbx), %r14
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
callq 0x690e
leaq -0x68(%rbp), %rdi
callq 0x3ac4
cmpq $0x0, (%r14)
je 0x5851
xorl %r12d, %r12d
leaq -0x50(%rbp), %r13
leaq -0x90(%rbp), %r14
leaq -0x70(%rbp), %r15
cmpl 0x8(%rbx), %r12d
jae 0x5851
movq %r13, %rdi
movq %rbx, %rsi
leaq -0x298(%rbp), %rdx
callq 0x5a78
movq -0x50(%rbp), %rsi
testq %rsi, %rsi
je 0x5848
addq $0x8, %rsi
movq -0x40(%rbp), %rdi
callq 0x6262
movq %rax, %rdi
movq %r13, %rsi
callq 0x6518
movq -0x50(%rbp), %rsi
addq $0xc, %rsi
movq %r14, %rdi
leaq -0x29(%rbp), %rdx
callq 0x631e
movq %r15, %rdi
movq %r14, %rsi
callq 0x5d86
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x62b4
movq %rax, %rdi
movq %r13, %rsi
callq 0x6518
movq %r15, %rdi
callq 0x3378
movq %r14, %rdi
callq 0x6358
leaq -0x48(%rbp), %rdi
callq 0x3ac4
incl %r12d
jmp 0x57b4
leaq -0x48(%rbp), %rdi
callq 0x3ac4
leaq -0x298(%rbp), %rdi
callq 0x3060
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x58a7
jmp 0x58a7
movq %rax, %r14
jmp 0x58b6
jmp 0x587f
movq %rax, %r14
jmp 0x5890
movq %rax, %r14
jmp 0x589c
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x3378
leaq -0x90(%rbp), %rdi
callq 0x6358
leaq -0x48(%rbp), %rdi
callq 0x3ac4
jmp 0x58aa
movq %rax, %r14
leaq -0x298(%rbp), %rdi
callq 0x3060
leaq 0x80(%rbx), %rdi
callq 0x3a38
movq -0x40(%rbp), %rdi
callq 0x3a4c
movq -0x38(%rbp), %rdi
callq 0x3b54
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x3ac4
movq %r14, %rdi
callq 0x3340
// File: /workspace/github_cpp_makefile_star2_O2/bluesky466[P]ResourcesParser/ResourcesParser.cpp
// Function: ResourcesParser::getStringFromResStringPool[abi:cxx11](std::shared_ptr<ResourcesParser::ResStringPool>, unsigned int)
string ResourcesParser::getStringFromResStringPool(
			ResourcesParser::ResStringPoolPtr pPool,
			uint32_t index) {
	if(index > pPool->header.stringCount) {
		return "???";
	}
	uint32_t offset = *(pPool->pOffsets.get() + index);
	//前两个字节是字符串长度
	char* str = ((char*) (pPool->pStrings.get() + offset + 2));
	return (pPool->header.flags & ResStringPool_header::UTF8_FLAG)
		? str
		: toUtf8((char16_t*) str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
cmpl %edx, 0x8(%rax)
jae 0x5dfd
leaq 0x44b1(%rip), %rsi      # 0xa2ac
jmp 0x5e3d
movl %edx, %ecx
movq 0x20(%rax), %rdx
movq 0x30(%rax), %rsi
movl (%rdx,%rcx,4), %ecx
addq %rcx, %rsi
addq $0x2, %rsi
testb $0x1, 0x11(%rax)
jne 0x5e3d
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x631e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5d86
leaq -0x38(%rbp), %rdi
callq 0x6358
jmp 0x5e49
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x3090
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x6358
movq %rbx, %rdi
callq 0x3340
nop