LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/Test/BasicStats_test.cpp
// Function: test_Average()
void test_Average()
{
  BasicStats a;
  a.insert(50);
  assert(a.Average()==50); //tests when there is only one number in the stream.       
        
  BasicStats b;
  for (int i=1;i<=100;i++) //tests for ascending number from 1 to 100. 
    b.insert(i);
  assert(b.Average()==50.5);
  
  BasicStats c; // tests with one million items in the stream in descending order 
  for (int i=1000000;i>=1;i--)
    c.insert(i);
  assert(c.Average()==500000.5);
  
  BasicStats d;
  double sum=0;
  int random_num;
  for(int i=0;i<100000;i++)
  {
     random_num=(rand()%1000+250);
     d.insert(random_num); //tests for a randomly generated stream
     sum=sum+random_num;
  }
   assert(d.Average()==sum/100000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorpd %xmm0, %xmm0
movsd 0x7d2(%rip), %xmm1      # 0x2008
movl $0x64, %eax
movapd %xmm1, %xmm2
addsd %xmm2, %xmm0
addsd %xmm1, %xmm2
decq %rax
jne 0x183f
divsd 0x7c4(%rip), %xmm0      # 0x2018
ucomisd 0x7e4(%rip), %xmm0      # 0x2040
jne 0x191b
jp 0x191b
xorpd %xmm0, %xmm0
movl $0xf4240, %eax          # imm = 0xF4240
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
decq %rax
jne 0x1871
divsd 0x79f(%rip), %xmm0      # 0x2028
ucomisd 0x7b7(%rip), %xmm0      # 0x2048
jne 0x193a
jp 0x193a
xorpd %xmm1, %xmm1
movl $0x186a0, %ebx          # imm = 0x186A0
xorpd %xmm2, %xmm2
movsd %xmm2, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
callq 0x1030
movsd -0x10(%rbp), %xmm2
movsd -0x18(%rbp), %xmm1
cltq
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
negl %ecx
addl %ecx, %eax
addl $0xfa, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
addsd %xmm0, %xmm2
addsd %xmm0, %xmm1
decq %rbx
jne 0x18aa
movsd 0x74c(%rip), %xmm0      # 0x2050
divsd %xmm0, %xmm2
divsd %xmm0, %xmm1
ucomisd %xmm1, %xmm2
jne 0x1959
jp 0x1959
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x84f(%rip), %rdi       # 0x2171
leaq 0x797(%rip), %rsi       # 0x20c0
leaq 0x82d(%rip), %rcx       # 0x215d
movl $0x50, %edx
callq 0x1040
leaq 0x842(%rip), %rdi       # 0x2183
leaq 0x778(%rip), %rsi       # 0x20c0
leaq 0x80e(%rip), %rcx       # 0x215d
movl $0x55, %edx
callq 0x1040
leaq 0x839(%rip), %rdi       # 0x2199
leaq 0x759(%rip), %rsi       # 0x20c0
leaq 0x7ef(%rip), %rcx       # 0x215d
movl $0x60, %edx
callq 0x1040
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/Test/BasicStats_test.cpp
// Function: main
int main()
{
  test_Average();
  test_MIN();
  test_MAX();
  test_SD();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1821
callq 0x13ab
callq 0x15a9
callq 0x1978
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./tsv.hpp
// Function: Common_sp::TsvOut& Common_sp::TsvOut::operator<<<char const*>(char const* const&)
TsvOut& operator<< (const T &field)
      { if (os)
        { if (lines && fields >= fields_max)
            throw runtime_error ("TsvOut: fields_max = " + to_string (fields_max));
          if (fields)  
            *os << '\t'; 
          else if (! lines && usePound)
            *os << '#';
          *os << field; 
          fields++;
        }
        return *this; 
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x135f8
movq %rsi, %rbx
cmpq $0x0, 0x10(%r14)
movq 0x20(%r14), %rax
je 0x135a2
cmpq 0x18(%r14), %rax
jae 0x13617
testq %rax, %rax
jne 0x135a7
jmp 0x135b9
testq %rax, %rax
je 0x13606
leaq 0x28(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
callq 0xa5e0
movq (%r14), %r15
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x135dc
movq %rbx, %rdi
callq 0xa250
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xa5e0
jmp 0x135f4
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0xa920
incq 0x20(%r14)
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, 0x28(%r14)
jne 0x135b9
leaq 0x28(%rsp), %rsi
movb $0x23, (%rsi)
jmp 0x135af
movl $0x10, %edi
callq 0xa2a0
movq %rax, %rbx
movq 0x18(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x12e65
leaq 0x5bf82(%rip), %rsi     # 0x6f5bb
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x13916
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xa8b0
xorl %ebp, %ebp
movq 0x7998f(%rip), %rsi     # 0x8cff0
movq 0x79908(%rip), %rdx     # 0x8cf70
movq %rbx, %rdi
callq 0xa940
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1368e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa540
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x136a9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa540
testb %bpl, %bpl
jne 0x136d3
jmp 0x136db
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x136d3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa540
jmp 0x136d3
movq %rax, %r14
movq %rbx, %rdi
callq 0xa400
movq %r14, %rdi
callq 0xa9a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./tsv.hpp
// Function: Common_sp::TsvOut::newLn()
void newLn ()
    { if (! os)
        return;
      *os << endl;
      if (! lines)
        fields_max = fields;
      lines++;
      if (fields != fields_max)
        throw runtime_error ("TsvOut: fields_max = " + to_string (fields_max) + ", but fields = " + to_string (fields));
      fields = 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x137b5
movq %rdi, %r14
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xa510
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa040
movq %rax, %rdi
callq 0xa3c0
movq 0x10(%r14), %rdx
movq 0x20(%r14), %rax
leaq 0x1(%rdx), %rcx
testq %rdx, %rdx
je 0x137a5
movq %rcx, 0x10(%r14)
cmpq 0x18(%r14), %rax
je 0x137ad
movl $0x10, %edi
callq 0xa2a0
movq %rax, %rbx
movq 0x18(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x12e65
leaq 0x5be57(%rip), %rsi     # 0x6f5bb
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x13916
leaq 0x5bf7f(%rip), %rsi     # 0x6f6f9
leaq 0x68(%rsp), %rdi
callq 0xaa50
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x137c3
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x137d0
movq %rax, 0x18(%r14)
movq %rcx, 0x10(%r14)
movq $0x0, 0x20(%r14)
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x12e65
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x11018
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0xa8b0
xorl %ebp, %ebp
movq 0x797c7(%rip), %rsi     # 0x8cff0
movq 0x79740(%rip), %rdx     # 0x8cf70
movq %rbx, %rdi
callq 0xa940
movq %rax, %r14
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13864
movq 0x98(%rsp), %rsi
incq %rsi
callq 0xa540
jmp 0x13864
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13887
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa540
jmp 0x13887
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x138a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa540
jmp 0x138a6
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x138c1
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa540
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x138dc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa540
testb %bpl, %bpl
jne 0x13906
jmp 0x1390e
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13906
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa540
jmp 0x13906
movq %rax, %r14
movq %rbx, %rdi
callq 0xa400
movq %r14, %rdi
callq 0xa9a0
// File: /workspace/github_cpp_makefile_star2_O3/mburhanpurkar[P]fast_xorshift_plus/./fast_rng.hpp
// Function: fast_rng::vec_xorshift_plus::vec_xorshift_plus()
vec_xorshift_plus()
    {
        if (!is_aligned(&s0,32) || !is_aligned(&s1,32))
	    throw std::runtime_error("Fatal: unaligned vec_xorshift_plus!  See discussion in fast_rng.hpp");
      
        std::random_device rd;
        s0 = _mm256_setr_epi64x(rng_helpers::rd64(rd), rng_helpers::rd64(rd), rng_helpers::rd64(rd), rng_helpers::rd64(rd));
	s1 = _mm256_setr_epi64x(rng_helpers::rd64(rd), rng_helpers::rd64(rd), rng_helpers::rd64(rd), rng_helpers::rd64(rd));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1398, %rsp           # imm = 0x1398
leaq 0x10(%rsp), %rbx
movq %rdi, 0x8(%rsp)
movq %rbx, %rdi
callq 0x28e0
movq %rbx, %rdi
callq 0x2170
movl %eax, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %r14d
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %r15d
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %r12d
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %r13d
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %ebx
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %ebp
callq 0x2170
movl 0x4(%rsp), %ecx
shlq $0x20, %rax
movl %ebp, %edi
shlq $0x20, %rbx
movl %r13d, %esi
shlq $0x20, %r14
shlq $0x20, %r12
movl %r15d, %edx
orq %rax, %rdi
movq 0x8(%rsp), %rax
orq %rbx, %rsi
orq %r12, %rdx
vmovq %rdi, %xmm0
vmovq %rsi, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovq %rdx, %xmm1
orq %r14, %rcx
vmovq %rcx, %xmm2
vmovdqa %xmm0, 0x10(%rax)
vpunpcklqdq %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
vmovdqa %xmm1, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x2170
movl %eax, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %r14d
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %r15d
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %r12d
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %r13d
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %ebx
callq 0x2170
leaq 0x10(%rsp), %rdi
movl %eax, %ebp
callq 0x2170
movl 0x4(%rsp), %ecx
shlq $0x20, %rax
movl %ebp, %edi
shlq $0x20, %rbx
movl %r13d, %esi
shlq $0x20, %r14
shlq $0x20, %r12
movl %r15d, %edx
orq %rax, %rdi
movq 0x8(%rsp), %rax
orq %rbx, %rsi
orq %r12, %rdx
vmovq %rdi, %xmm0
vmovq %rsi, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovq %rdx, %xmm1
orq %r14, %rcx
vmovq %rcx, %xmm2
vmovdqa %xmm0, 0x30(%rax)
vpunpcklqdq %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
vmovdqa %xmm1, 0x20(%rax)
leaq 0x10(%rsp), %rdi
callq 0x2120
addq $0x1398, %rsp           # imm = 0x1398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3137
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x29df
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: read_sections(std::vector<unsigned char, std::allocator<unsigned char>> const&)
std::vector<section> read_sections(const std::vector<uint8_t> &section_data) {

	std::vector<section> sections;
	auto iter = section_data.begin();
	while (iter != section_data.end()) {

		section s;

		s.number = read_8(iter);
		s.flags = read_8(iter);
		s.size = read_32(iter);
		s.org = read_32(iter);

		if (!(s.flags & SEC_NONAME)) s.name = read_cstring(iter);

		sections.emplace_back(std::move(s));
	}
	return sections;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq %rax, (%rsp)
cmpq 0x8(%rsi), %rax
je 0x2738
movq %rsi, %r14
leaq 0x18(%rsp), %rbp
xorl %r12d, %r12d
leaq 0x38(%rsp), %r15
leaq 0x8(%rsp), %r13
movq %rbp, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movw $0x0, 0x28(%rsp)
movq %r12, 0x2c(%rsp)
movb (%rax), %cl
leaq 0x1(%rax), %rdx
movq %rdx, (%rsp)
movb %cl, 0x28(%rsp)
movb 0x1(%rax), %cl
leaq 0x2(%rax), %rdx
movq %rdx, (%rsp)
movb %cl, 0x29(%rsp)
movzbl 0x2(%rax), %edx
leaq 0x3(%rax), %rsi
movq %rsi, (%rsp)
movzbl 0x3(%rax), %esi
shll $0x8, %esi
orl %edx, %esi
leaq 0x4(%rax), %rdx
movq %rdx, (%rsp)
movzbl 0x4(%rax), %edx
shll $0x10, %edx
orl %esi, %edx
leaq 0x5(%rax), %rsi
movq %rsi, (%rsp)
movzbl 0x5(%rax), %esi
shll $0x18, %esi
orl %edx, %esi
leaq 0x6(%rax), %rdx
movq %rdx, (%rsp)
movl %esi, 0x2c(%rsp)
movzbl 0x6(%rax), %edx
leaq 0x7(%rax), %rsi
movq %rsi, (%rsp)
movzbl 0x7(%rax), %esi
shll $0x8, %esi
orl %edx, %esi
movzbl 0x8(%rax), %edx
shll $0x10, %edx
orl %esi, %edx
movzbl 0x9(%rax), %esi
shll $0x18, %esi
orl %edx, %esi
addq $0xa, %rax
movq %rax, (%rsp)
movl %esi, 0x30(%rsp)
testb $0x40, %cl
jne 0x2708
movq %r15, %rdi
movq %rsp, %rsi
callq 0x64b1
movq %r13, %rdi
movq %r15, %rsi
callq 0x2220
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x2708
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6512
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x272a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%rsp), %rax
cmpq 0x8(%r14), %rax
jne 0x2623
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x274c
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2766
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x658e
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: read_symbols(std::vector<unsigned char, std::allocator<unsigned char>> const&)
std::vector<symbol> read_symbols(const std::vector<uint8_t> &symbol_data) {

	std::vector<symbol> symbols;

	auto iter = symbol_data.begin();
	while (iter != symbol_data.end()) {
		symbol s;
		s.type = read_8(iter);
		s.flags = read_8(iter);
		s.section = read_8(iter);
		s.offset = s.type == S_UND ? 0 : read_32(iter);
		s.name = read_cstring(iter);


		symbols.emplace_back(std::move(s));
	}

	return symbols;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
cmpq 0x8(%rsi), %rax
je 0x28c6
movq %rsi, %r14
leaq 0x20(%rsp), %rbp
leaq 0x38(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %rbp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movw $0x0, 0x30(%rsp)
movb $-0x1, 0x32(%rsp)
movl $0x0, 0x34(%rsp)
movb (%rax), %cl
leaq 0x1(%rax), %rdx
movq %rdx, 0x8(%rsp)
movb %cl, 0x30(%rsp)
movb 0x1(%rax), %dl
leaq 0x2(%rax), %rsi
movq %rsi, 0x8(%rsp)
movb %dl, 0x31(%rsp)
movb 0x2(%rax), %dl
leaq 0x3(%rax), %rsi
movq %rsi, 0x8(%rsp)
movb %dl, 0x32(%rsp)
testb %cl, %cl
je 0x285d
movzbl 0x3(%rax), %ecx
leaq 0x4(%rax), %rdx
movq %rdx, 0x8(%rsp)
movzbl 0x4(%rax), %edx
shll $0x8, %edx
orl %ecx, %edx
leaq 0x5(%rax), %rcx
movq %rcx, 0x8(%rsp)
movzbl 0x5(%rax), %esi
shll $0x10, %esi
orl %edx, %esi
leaq 0x6(%rax), %rcx
movq %rcx, 0x8(%rsp)
movzbl 0x6(%rax), %ecx
shll $0x18, %ecx
orl %esi, %ecx
addq $0x7, %rax
movq %rax, 0x8(%rsp)
jmp 0x285f
xorl %ecx, %ecx
movl %ecx, 0x34(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x64b1
movq %r13, %rdi
movq %r15, %rsi
callq 0x2220
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x2895
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x65ec
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x28b7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21c0
movq 0x8(%rsp), %rax
cmpq 0x8(%r14), %rax
jne 0x27be
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28da
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x28f4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x6662
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: dump(char const*)
void dump(const char *name) {
	Header h;
	int fd;
	ssize_t ok;

	fd = open(name, O_RDONLY | O_BINARY);
	if (fd < 0) err(EX_NOINPUT, "Unable to open %s", name);


	ok = read(fd, &h, sizeof(h));
	if (ok != sizeof(h))
		errx(EX_DATAERR, "%s is not an object file", name);

	le_to_host(h.magic);
	le_to_host(h.version);
	le_to_host(h.filetype);

	if (h.magic != MOD_MAGIC || h.version != 1 || h.filetype > 2)
		errx(EX_DATAERR, "%s is not an object file", name);

	lseek(fd, 0, SEEK_SET);
	if (h.filetype == 2) dump_lib(name, fd);

	// files may contain multiple modules.
	while (dump_obj(name, fd)) /* ... */;

	close(fd);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %esi, %esi
xorl %eax, %eax
callq 0x2150
testl %eax, %eax
js 0x6403
movl %eax, %ebp
leaq 0x8(%rsp), %rsi
movl $0x7, %edx
movl %eax, %edi
callq 0x2250
cmpq $0x7, %rax
jne 0x63ed
cmpl $0x5a44525a, 0x8(%rsp)  # imm = 0x5A44525A
jne 0x63ed
cmpw $0x1, 0xc(%rsp)
jne 0x63ed
movb 0xe(%rsp), %r14b
cmpb $0x3, %r14b
jae 0x63ed
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2300
cmpb $0x2, %r14b
jne 0x63d0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x608c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2904
testb %al, %al
jne 0x63d0
movl %ebp, %edi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2330
leaq 0x8cc8(%rip), %rsi      # 0xf0bc
movl $0x41, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2310
leaq 0x8f60(%rip), %rsi      # 0xf36a
movl $0x42, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: main
int main(int argc, char **argv) {

	int c;
	while ((c = getopt(argc, argv, "Sgn")) != -1) {
			switch(c) {
				case 'S': flags.S = true; break;
				case 'g': flags.g = true; break;
				case 'n': flags.n = true; break;
				default: exit(EX_USAGE); break;
			}
	}

	argv += optind;
	argc -= optind;

	if (argc == 0) usage();

	for (int i = 0; i < argc; ++i) {
		dump(argv[i]);
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x8f4e(%rip), %r15      # 0xf37c
leaq 0xdd9b(%rip), %r12      # 0x141d0
leaq 0xdd95(%rip), %r13      # 0x141d1
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2060
cmpl $0x66, %eax
jle 0x645d
cmpl $0x67, %eax
je 0x643c
cmpl $0x6e, %eax
jne 0x64a7
movq %r13, %rcx
jmp 0x6465
movq %r12, %rcx
cmpl $0x53, %eax
jne 0x646a
movb $0x1, (%rcx)
jmp 0x643c
cmpl $-0x1, %eax
jne 0x64a7
movq 0xdb6a(%rip), %rax      # 0x13fe0
movslq (%rax), %rax
subl %eax, %ebx
je 0x64a7
testl %ebx, %ebx
jle 0x649b
leaq (%r14,%rax,8), %r14
movl %ebx, %ebx
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
callq 0x6363
incq %r15
cmpq %r15, %rbx
jne 0x648a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x40, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> read_cstring<__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>&)
std::string read_cstring(T &iter) {
	std::string s;
	for(;;) {
		uint8_t c = *iter;
		++iter;
		if (!c) break;
		s.push_back(c);
	}
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%r14), %rcx
movb (%rcx), %al
incq %rcx
movq %rcx, (%r14)
testb %al, %al
je 0x64eb
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2180
jmp 0x64cf
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x650a
movq (%r15), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> read_pstring<__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>&)
std::string read_pstring(T &iter) {
	std::string s;
	unsigned  size = *iter;
	++iter;
	s.reserve(size);
	while (size--) {
		uint8_t c = *iter;
		++iter;
		s.push_back(c);
	}
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
movzbl (%rax), %r15d
incq %rax
movq %rax, (%rsi)
movq %r15, %rsi
callq 0x2290
incl %r15d
decl %r15d
je 0x6931
movq (%r14), %rax
movsbl (%rax), %esi
incq %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x2180
jmp 0x6916
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x6942
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6959
movq (%r12), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::to_x[abi:cxx11](unsigned int, unsigned int, char)
std::string disassembler::to_x(uint32_t x, unsigned bytes, char prefix) {
	std::string s;
	char buffer[16];
	if (prefix) s.push_back(prefix);

	if (x > 0xff && bytes < 4) bytes = 4;
	if (x > 0xffff && bytes < 6) bytes = 6;
	if (x > 0xffffff && bytes < 8) bytes = 8;

	memset(buffer, '0', sizeof(buffer));
	int i = 16;
	while (x) {
		buffer[--i] = "0123456789abcdef"[x & 0x0f];
		x >>= 4;
	}

	s.append(buffer + 16 - bytes, buffer + 16);

	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testb %cl, %cl
je 0x742c
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x2180
cmpl $0x5, %r14d
movl $0x4, %eax
cmovael %r14d, %eax
cmpl $0x100, %ebp            # imm = 0x100
cmovbl %r14d, %eax
cmpl $0x7, %eax
movl $0x6, %ecx
cmovael %eax, %ecx
cmpl $0x10000, %ebp          # imm = 0x10000
cmovbl %eax, %ecx
cmpl $0x9, %ecx
movl $0x8, %eax
cmovael %ecx, %eax
cmpl $0x1000000, %ebp        # imm = 0x1000000
cmovbl %ecx, %eax
movaps 0x805e(%rip), %xmm0     # 0xf4d0
movaps %xmm0, (%rsp)
testl %ebp, %ebp
je 0x74a1
leaq 0xf(%rsp), %rcx
leaq 0x87f2(%rip), %rdx      # 0xfc78
movl %ebp, %esi
movl %ebp, %edi
andl $0xf, %edi
movb (%rdi,%rdx), %dil
movb %dil, (%rcx)
shrl $0x4, %esi
decq %rcx
cmpl $0xf, %ebp
movl %esi, %ebp
ja 0x7488
movl %eax, %r8d
movq %rsp, %rcx
subq %r8, %rcx
addq $0x10, %rcx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x21f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x74cc
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x74e2
movq (%r15), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::operand_size(unsigned char, bool, bool)
int disassembler::operand_size(uint8_t op, bool m, bool x) {
	unsigned mode = modes[op];
	unsigned size = mode & 0x0f;
	if ((mode & m_I) && x) size++; 
	if ((mode & m_M) && m) size++;
	return size;
}

// Assembly:
movl %edi, %eax
leaq 0x805d(%rip), %rcx      # 0xf550
movl (%rcx,%rax,4), %eax
movl %eax, %ecx
andl $0xf, %ecx
movl %eax, %edi
shrl $0x4, %edi
andl %edx, %edi
addl %ecx, %edi
shrl $0x5, %eax
andl %esi, %eax
addl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::emit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::emit(const std::string &label, const std::string &opcode) {
	std::string tmp;
	tmp = label;

	if (!opcode.empty()) {
		indent_to(tmp, kOpcodeTab);
		tmp += opcode;
	}

	tmp.push_back('\n');
	fputs(tmp.c_str(), stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x7590
cmpq $0x13, 0x10(%rsp)
ja 0x7583
leaq 0x8(%rsp), %rdi
movl $0x14, %esi
movl $0x20, %edx
callq 0x2080
movq 0x8(%rbx), %rdx
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
movl $0xa, %esi
callq 0x2180
movq 0x8(%rsp), %rdi
movq 0xca1d(%rip), %rax      # 0x13fc8
movq (%rax), %rsi
callq 0x21e0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x75ca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x75ec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::emit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::emit(const std::string &label, const std::string &opcode, const std::string &operand) {

	std::string tmp;
	tmp = label;


	if (!opcode.empty()) {
		indent_to(tmp, kOpcodeTab);
		tmp += opcode;
	}

	if (!operand.empty()) {
		indent_to(tmp, kOperandTab);
		tmp += operand;
	}

	tmp.push_back('\n');
	fputs(tmp.c_str(), stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rsp, %rdi
callq 0x20e0
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x7655
cmpq $0x13, 0x8(%rsp)
ja 0x764a
movq %rsp, %rdi
movl $0x14, %esi
movl $0x20, %edx
callq 0x2080
movq 0x8(%r14), %rdx
movq (%r14), %rsi
movq %rsp, %rdi
callq 0x2090
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x7687
cmpq $0x1d, 0x8(%rsp)
ja 0x767c
movq %rsp, %rdi
movl $0x1e, %esi
movl $0x20, %edx
callq 0x2080
movq 0x8(%rbx), %rdx
movq (%rbx), %rsi
movq %rsp, %rdi
callq 0x2090
movq %rsp, %rdi
movl $0xa, %esi
callq 0x2180
movq (%rsp), %rdi
movq 0xc929(%rip), %rax      # 0x13fc8
movq (%rax), %rsi
callq 0x21e0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x76bd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21c0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x76e0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::emit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::emit(const std::string &label, const std::string &opcode, const std::string &operand, const std::string &comment) {

	std::string tmp;
	tmp = label;

	if (!opcode.empty()) {
		indent_to(tmp, kOpcodeTab);
		tmp += opcode;
	}

	if (!operand.empty()) {
		indent_to(tmp, kOperandTab);
		tmp += operand;
	}

	if (!comment.empty()) {
		indent_to(tmp, kCommentTab);
		tmp += "; ";
		tmp += comment;	
	}

	tmp.push_back('\n');
	fputs(tmp.c_str(), stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x7757
cmpq $0x13, 0x10(%rsp)
ja 0x774a
leaq 0x8(%rsp), %rdi
movl $0x14, %esi
movl $0x20, %edx
callq 0x2080
movq 0x8(%r15), %rdx
movq (%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2090
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x778d
cmpq $0x1d, 0x10(%rsp)
ja 0x7780
leaq 0x8(%rsp), %rdi
movl $0x1e, %esi
movl $0x20, %edx
callq 0x2080
movq 0x8(%r14), %rdx
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2090
cmpq $0x0, 0x8(%rbx)
je 0x77d2
cmpq $0x4f, 0x10(%rsp)
ja 0x77b0
leaq 0x8(%rsp), %rdi
movl $0x50, %esi
movl $0x20, %edx
callq 0x2080
leaq 0x84d2(%rip), %rsi      # 0xfc89
leaq 0x8(%rsp), %rdi
callq 0x2320
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
movl $0xa, %esi
callq 0x2180
movq 0x8(%rsp), %rdi
movq 0xc7db(%rip), %rax      # 0x13fc8
movq (%rax), %rsi
callq 0x21e0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x780c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7832
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::format_data[abi:cxx11](unsigned int, unsigned char const*)
std::pair<std::string, std::string> 
disassembler::format_data(unsigned size, const uint8_t *data) {

	std::string tmp;

	for (unsigned i = 0; i < size; ++i) {
		if (i > 0) tmp += ", ";
		tmp += to_x(data[i], 2, '$');
	}

	return std::make_pair("db", tmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r15
leaq 0x40(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
testl %edx, %edx
je 0x78ff
movq %rcx, %r14
movq %r15, 0x50(%rsp)
leaq 0x18(%rsp), %rbp
movl %edx, %ebx
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
leaq 0x30(%rsp), %r12
testq %r13, %r13
je 0x78a1
movq %r12, %rdi
leaq 0x7976(%rip), %rsi      # 0xf212
callq 0x2320
movzbl (%r14,%r13), %esi
movq %r15, %rdi
movl $0x2, %edx
movl $0x24, %ecx
callq 0x73f8
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x2090
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x78e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
incq %r13
cmpq %r13, %rbx
jne 0x788d
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x40(%rsp), %rbx
movq 0x50(%rsp), %r15
jmp 0x7904
xorl %edx, %edx
movq %rbx, %rsi
leaq 0x8381(%rip), %rax      # 0xfc8c
leaq 0x10(%rsp), %rdi
movq %rax, -0x8(%rdi)
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rdx
callq 0x69ce
movq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x6718
leaq 0x30(%r15), %rax
movq %rax, 0x20(%r15)
movq 0x10(%rsp), %rcx
cmpq %r14, %rcx
je 0x7958
movq %rcx, 0x20(%r15)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%r15)
jmp 0x795f
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%r15)
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x797f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x79c8
movq 0x20(%rsp), %rsi
jmp 0x79c0
jmp 0x79a9
jmp 0x79a9
movq %rax, %rbx
jmp 0x79c8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x79c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x79e4
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::hexdump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void disassembler::hexdump(std::string &line) {
	// print pc and hexdump...

	indent_to(line, kCommentTab);
	line += "; ";

	line += to_x(_pc, 4);
	line.push_back(':');

	int i;
	for (i = 0; i < _st; ++i) {
		line.push_back(' ');
		line += to_x(_bytes[i], 2);
	}
	for ( ; i < 4; ++i) {
		line += "   ";
	}
	line += "  ";
	for (i = 0; i < _st; ++i) {
		uint8_t c = _bytes[i];
		// msb flag?
		if (_traits & msb_hexdump) c &= 0x7f;
		if (isprint(c) && isascii(c)) line += c;
		else line += '.';
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x4f, 0x8(%rsi)
ja 0x7e89
movl $0x50, %esi
movq %rbx, %rdi
movl $0x20, %edx
callq 0x2080
leaq 0x7df9(%rip), %rsi      # 0xfc89
movq %rbx, %rdi
callq 0x2320
movl 0x20(%r14), %esi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x73f8
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x2090
leaq 0x18(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x7eda
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x2180
cmpl $0x0, 0x8(%r14)
je 0x7f5a
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x20, %esi
callq 0x2180
movzbl 0x18(%r14,%r12), %esi
movq %r15, %rdi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x73f8
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2090
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x7f41
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
incq %r12
movl 0x8(%r14), %eax
cmpq %rax, %r12
jb 0x7ef6
leaq -0x1(%r12), %rax
cmpq $0x2, %rax
jbe 0x7f5d
jmp 0x7f78
xorl %r12d, %r12d
addl $-0x4, %r12d
leaq 0x7d4e(%rip), %r15      # 0xfcb6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2320
incl %r12d
jne 0x7f68
leaq 0x7d38(%rip), %rsi      # 0xfcb7
movq %rbx, %rdi
callq 0x2320
cmpl $0x0, 0x8(%r14)
je 0x7fe1
xorl %r15d, %r15d
movzbl 0x18(%r14,%r15), %eax
movl %eax, %ecx
andb $0x7f, %cl
testb $0x8, 0x34(%r14)
movzbl %cl, %r12d
cmovel %eax, %r12d
movzbl %r12b, %ebp
movl %ebp, %edi
callq 0x22d0
testb %bpl, %bpl
jns 0x7fbf
movl $0x2e, %r12d
testl %eax, %eax
jne 0x7fc9
movl $0x2e, %r12d
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x2180
incq %r15
movl 0x8(%r14), %eax
cmpq %rax, %r15
jb 0x7f91
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x8010
jmp 0x801d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x801d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int)
void disassembler::dump(const std::string &expr, unsigned size, uint32_t value) {

	std::string line;

	if (_st) dump();

	for (_st = 0; _st < size; ++_st) {
		_bytes[_st] = value & 0xff;
		value >>= 8;
	}

	auto p = format_data(size, expr);

	indent_to(line, kOpcodeTab);
	line += p.first;
	indent_to(line, kOperandTab);
	line += p.second;

	hexdump(line);
	line.push_back('\n');
	fputs(line.c_str(), stdout);

	_pc += _st;
	reset();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpl $0x0, 0x8(%rdi)
je 0x8063
movq %rbx, %rdi
callq 0x7cfc
testl %ebp, %ebp
je 0x807c
movl %ebp, %eax
xorl %ecx, %ecx
movb %r15b, 0x18(%rbx,%rcx)
shrl $0x8, %r15d
incq %rcx
cmpq %rcx, %rax
jne 0x806b
movl %ebp, 0x8(%rbx)
movq (%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r14, %rcx
callq *0x18(%rax)
cmpq $0x13, 0x8(%rsp)
ja 0x80ac
movq %rsp, %rdi
movl $0x14, %esi
movl $0x20, %edx
callq 0x2080
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rsp, %rdi
callq 0x2090
cmpq $0x1d, 0x8(%rsp)
ja 0x80d8
movq %rsp, %rdi
movl $0x1e, %esi
movl $0x20, %edx
callq 0x2080
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %rsp, %rdi
callq 0x2090
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7e5c
movq %rsp, %rdi
movl $0xa, %esi
callq 0x2180
movq (%rsp), %rdi
movq 0xbebb(%rip), %rax      # 0x13fc8
movq (%rax), %rsi
callq 0x21e0
movl 0x8(%rbx), %eax
addl %eax, 0x20(%rbx)
xorl %eax, %eax
movl %eax, 0x24(%rbx)
movl %eax, 0x8(%rbx)
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x813e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21c0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8159
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x816f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21c0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x817e
movq %rax, %rbx
jmp 0x8190
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x92e4
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x81a6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int)
void disassembler::operator()(const std::string &expr, unsigned size, uint32_t value) {

	if (_st == 0 || !_code)
		check_labels();

	if (!_code) {
		dump(expr, size, value);
		if (_inline_data) {
			_inline_data -= size;
			if (_inline_data <= 0) _code = true; 
		}
		return;
	}

	if (_st != 1 || size != _size) {
		dump(expr, size, value);
		return;
	}
	for (int i = 0; i < size; ++i) {
		_bytes[_st++] = value & 0xff;
		value >>= 8;
	}
	print(expr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x84cb
movb 0x28(%rbx), %al
testb %al, %al
jne 0x84d6
movq %rbx, %rdi
callq 0x81ca
movb 0x28(%rbx), %al
testb $0x1, %al
je 0x8519
cmpl $0x1, 0x8(%rbx)
jne 0x8549
cmpl %r15d, 0x10(%rbx)
jne 0x8549
testl %r15d, %r15d
je 0x8504
movl %r15d, %ecx
xorl %eax, %eax
movb %bpl, 0x19(%rbx,%rax)
shrl $0x8, %ebp
incq %rax
cmpl %eax, %ecx
jne 0x84f0
incl %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8564
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x8026
movl 0x2c(%rbx), %eax
testl %eax, %eax
je 0x853e
subl %r15d, %eax
movl %eax, 0x2c(%rbx)
testl %eax, %eax
jg 0x853e
movb $0x1, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8026
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::print(const std::string &expr) {


	std::string line;

	indent_to(line, kOpcodeTab);
	line.append(&opcodes[_op * 3], 3);

	if (_size) {

		indent_to(line, kOperandTab);
		line += prefix();
		line += expr;
		line += suffix();
	}

	hexdump(line);
	line.push_back('\n');
	fputs(line.c_str(), stdout);

	_pc += _size + 1;
	reset();	
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rdi
movl $0x14, %esi
movl $0x20, %edx
callq 0x2080
movzbl 0xc(%rbx), %eax
leaq (%rax,%rax,2), %rax
leaq 0x73a3(%rip), %rsi      # 0xf950
addq %rax, %rsi
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x2050
cmpl $0x0, 0x10(%rbx)
je 0x866b
cmpq $0x1d, 0x10(%rsp)
ja 0x85e5
leaq 0x8(%rsp), %rdi
movl $0x1e, %esi
movl $0x20, %edx
callq 0x2080
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x8eb6
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x38(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x8622
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x8f88
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2090
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x866b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7e5c
leaq 0x8(%rsp), %rdi
movl $0xa, %esi
callq 0x2180
movq 0x8(%rsp), %rdi
movq 0xb935(%rip), %rax      # 0x13fc8
movq (%rax), %rsi
callq 0x21e0
movl 0x10(%rbx), %eax
movl 0x20(%rbx), %ecx
addl %ecx, %eax
incl %eax
movl %eax, 0x20(%rbx)
xorl %eax, %eax
movl %eax, 0x24(%rbx)
movl %eax, 0x8(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x86c7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
jne 0x86f5
jmp 0x8709
jmp 0x8706
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8709
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21c0
jmp 0x8709
jmp 0x8706
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8720
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::prefix[abi:cxx11]()
std::string disassembler::prefix() {

	std::string tmp;

	switch(_mode & 0xf000) {
		case mImmediate: tmp = "#"; break;
		case mDP: tmp = "<"; break;
		case mDPI: tmp = "(<"; break;
		case mDPIL: tmp = "[<"; break;
		case mAbsoluteIL: tmp = "["; break;

		case mRelative:
		case mBlockMove:
			break;

		// cop, brk are treated as absolute.
		case mAbsolute: 
			//if (_size == 1) printf("\t");
			if (_size > 1) tmp = "|";
			break;
		case mAbsoluteLong: tmp = ">"; break;
		case mAbsoluteI: tmp = "("; break;
	}
	return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0xf000, %eax           # imm = 0xF000
andl 0x14(%rsi), %eax
addl $0xfffff000, %eax       # imm = 0xFFFFF000
shrl $0xc, %eax
cmpl $0x7, %eax
ja 0x8f60
movl $0x1, %r8d
leaq 0x6621(%rip), %rcx      # 0xf514
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6d9c(%rip), %rcx      # 0xfc9f
jmp 0x8f54
leaq 0x62a1(%rip), %rcx      # 0xf1ad
jmp 0x8f54
leaq 0x6d94(%rip), %rcx      # 0xfca9
jmp 0x8f54
leaq 0x6d89(%rip), %rcx      # 0xfca7
jmp 0x8f54
movl $0x2, %r8d
leaq 0x6d77(%rip), %rcx      # 0xfca4
jmp 0x8f54
cmpl $0x1, 0x10(%rsi)
jbe 0x8f60
leaq 0x6278(%rip), %rcx      # 0xf1b4
jmp 0x8f54
leaq 0x6d5d(%rip), %rcx      # 0xfca2
jmp 0x8f54
movl $0x2, %r8d
leaq 0x6d4d(%rip), %rcx      # 0xfca1
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2280
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8f7f
movq (%r15), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::suffix[abi:cxx11]()
std::string disassembler::suffix() {

	std::string tmp;

	switch(_mode & 0x0f00) {
		case m_X: tmp = ",x"; break;
		case m_Y: if (!(_mode & (mDPI|mDPIL))) tmp = ",y"; break;
		case m_S:
		case m_S | m_Y:
			tmp = ",s"; break;
	}

	switch(_mode & 0xf000) {
		case mAbsoluteI:
		case mDPI:
			tmp += ")"; break;
		case mAbsoluteIL:
		case mDPIL:
			tmp += "]"; break;
	}

	// (xxx,s),y
	// (xxx),y
	// [xxx],y
	switch(_mode & 0x0f00) {
		case m_Y:
			if (_mode & (mDPI|mDPIL)) tmp += ",y"; break;
		case m_S | m_Y:
			tmp += ",y"; break;
	}	
	return tmp;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x14(%rsi), %eax
movl %eax, %ecx
andl $0xf00, %ecx            # imm = 0xF00
addl $0xffffff00, %ecx       # imm = 0xFFFFFF00
shrl $0x8, %ecx
cmpl $0x4, %ecx
ja 0x9001
leaq 0x656e(%rip), %rdx      # 0xf534
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x6cdb(%rip), %rcx      # 0xfcb1
jmp 0x8fef
testl $0xf000, %eax           # imm = 0xF000
jne 0x9001
leaq 0x6cc8(%rip), %rcx      # 0xfcae
jmp 0x8fef
leaq 0x6cbc(%rip), %rcx      # 0xfcab
movl $0x2, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2280
movl $0xf000, %eax           # imm = 0xF000
andl 0x14(%r14), %eax
addl $0xffffd000, %eax       # imm = 0xFFFFD000
cmpl $0x5fff, %eax           # imm = 0x5FFF
ja 0x903b
shrl $0xc, %eax
movl $0x33, %ecx
btl %eax, %ecx
jae 0x903b
movl %eax, %eax
leaq 0x6c34(%rip), %rcx      # 0xfc60
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x2320
movl 0x14(%r14), %eax
movl %eax, %ecx
andl $0xf00, %ecx            # imm = 0xF00
cmpl $0x500, %ecx            # imm = 0x500
je 0x905e
cmpl $0x400, %ecx            # imm = 0x400
jne 0x906d
testl $0xf000, %eax           # imm = 0xF000
je 0x906d
leaq 0x6c49(%rip), %rsi      # 0xfcae
movq %rbx, %rdi
callq 0x2320
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x908c
movq (%r15), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: analyzer::finish()
const std::vector<uint32_t> &analyzer::finish() {
	std::sort(_labels.begin(), _labels.end());
	auto end = std::unique(_labels.begin(), _labels.end());
	_labels.erase(end, _labels.end());
	return _labels;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x28(%rdi), %rbx
movq 0x28(%rdi), %r15
movq 0x30(%rdi), %r12
cmpq %r12, %r15
je 0x916c
movq %rdi, %r14
movq %r12, %rax
subq %r15, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x93a9
movq %r15, %rdi
movq %r12, %rsi
callq 0x948c
movq 0x28(%r14), %rcx
movq 0x30(%r14), %rax
cmpq %rax, %rcx
je 0x916c
addq $0x4, %rcx
cmpq %rax, %rcx
je 0x916c
movl -0x4(%rcx), %edx
leaq 0x4(%rcx), %rsi
cmpl (%rcx), %edx
movq %rsi, %rcx
jne 0x912e
leaq -0x8(%rsi), %rcx
cmpq %rax, %rsi
je 0x915f
movl %edx, %edi
movl (%rsi), %edx
cmpl %edx, %edi
je 0x9159
movl %edx, 0x4(%rcx)
addq $0x4, %rcx
addq $0x4, %rsi
jmp 0x9145
addq $0x4, %rcx
cmpq %rax, %rcx
je 0x916c
movq %rcx, 0x30(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/disassembler.cpp
// Function: analyzer::operator()(unsigned char)
void analyzer::operator()(uint8_t byte) {


	if (!_code) {

		if (_inline_data && --_inline_data <= 0) {
			_code = true;
			reset();
			return;
		}
		return;
	}

	_st++;
	if (_st == 1) {
		_op = byte;
		_mode = modes[_op];

		_size = _mode & 0x0f;
		if (_mode & _flags & m_I) _size++;
		if (_mode & _flags & m_M) _size++;

		if (!_size) { reset(); }
		return;
	}
	unsigned shift = (_st - 2) * 8;
	_arg = _arg + (byte << shift);
	if (_st <= _size) return;


	// all done... now process it
	process();
}

// Assembly:
cmpb $0x0, 0x8(%rdi)
je 0x91a8
movl 0xc(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0xc(%rdi)
testl %ecx, %ecx
je 0x91cd
shll $0x3, %ecx
movzbl %sil, %edx
addb $-0x8, %cl
shll %cl, %edx
addl %edx, 0x20(%rdi)
cmpl 0x14(%rdi), %eax
ja 0x9218
retq
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x91a7
leal -0x1(%rax), %ecx
movl %ecx, 0x4(%rdi)
cmpl $0x1, %eax
jg 0x91a7
movb $0x1, 0x8(%rdi)
movl 0xc(%rdi), %eax
addl %eax, 0x1c(%rdi)
xorl %eax, %eax
movl %eax, 0x20(%rdi)
movl %eax, 0xc(%rdi)
retq
movb %sil, 0x10(%rdi)
movzbl %sil, %ecx
leaq 0x6374(%rip), %rdx      # 0xf550
movl (%rdx,%rcx,4), %edx
movl %edx, 0x24(%rdi)
movl %edx, %ecx
andl $0xf, %ecx
movl %ecx, 0x14(%rdi)
andl 0x18(%rdi), %edx
testb $0x10, %dl
je 0x91f7
incl %ecx
movl %ecx, 0x14(%rdi)
testb $0x20, %dl
jne 0x9202
testl %ecx, %ecx
jne 0x91a7
jmp 0x91c1
incl %ecx
movl %ecx, 0x14(%rdi)
retq