LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/nompelis[P]INTecplotLib/main.cpp
// Function: main
int main( int argc, char *argv[] )
{
   char *fname = (char *) (argv[1]);

//while(1) {

   inTec_File f( fname );
   f.OpenRead();
   f.Parse();
   f.Close();
   inTec_Zone *z = f.GetZone( 0 );
   z->Dump( (char*) "CRAPCRAP.dat");//HACK

   printf("Zone type: %d \n", z->GetType() );
   printf("Zone variables: %d \n", z->GetNumVariables() );
   printf("Zone (not real) im: %ld \n",z->GetNumIndices( 1 ) );
   printf("Zone (not real) jm: %ld \n",z->GetNumIndices( 2 ) );
   printf("Zone (not real) km: %ld \n",z->GetNumIndices( 3 ) );
   printf("Zone nodes: %ld elements: %ld \n",
             z->GetNumNodes(), z->GetNumElements() );
   const unsigned long* icon = z->GetConnectivityPtr();
   printf(" %ld %ld %ld %ld \n",icon[0],icon[1],icon[2],icon[3]);
// 41 42 2 1
// 42 43 3 2
// 43 44 4 3
   const double* d = z->GetVariablePtr( 0 );
   printf(" %16.9e %16.9e %16.9e \n", d[0], d[1], d[2] );
//  5.000000000E-02 5.214617101E-02 5.437147251E-02


  printf("========================= LOOP ==========================\n");
//}

   return(0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x10d0
movq %rbx, %rdi
callq 0x1120
leaq 0x8(%rsp), %rdi
callq 0x1030
leaq 0x8(%rsp), %rdi
callq 0x10a0
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1110
movq %rax, %rbx
leaq 0xd7b(%rip), %rsi       # 0x2004
movq %rax, %rdi
callq 0x1130
movq %rbx, %rdi
callq 0x1050
leaq 0xd71(%rip), %rdi       # 0x2011
movl %eax, %esi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x10c0
leaq 0xd69(%rip), %rdi       # 0x2021
movl %eax, %esi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10f0
leaq 0xd61(%rip), %rdi       # 0x2036
movq %rax, %rsi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10f0
leaq 0xd5d(%rip), %rdi       # 0x2050
movq %rax, %rsi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
movl $0x3, %esi
callq 0x10f0
leaq 0xd59(%rip), %rdi       # 0x206a
movq %rax, %rsi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x10b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1060
leaq 0xd4f(%rip), %rdi       # 0x2084
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x1070
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movq 0x18(%rax), %r8
leaq 0xd44(%rip), %rdi       # 0x20a4
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1080
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
leaq 0xd31(%rip), %rdi       # 0x20b7
movb $0x3, %al
callq 0x1040
leaq 0xd3b(%rip), %rdi       # 0x20cf
callq 0x10e0
leaq 0x8(%rsp), %rdi
callq 0x1090
xorl %eax, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
jmp 0x13b6
jmp 0x13b6
jmp 0x13b6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/bloody76[P]Chip8-Disassembler/src/disassembler.cc
// Function: parse(std::basic_ifstream<char, std::char_traits<char>>&)
void parse(std::ifstream& rom)
{
    uint8   op1 = 0;
    uint8   op2 = 0;
    uint16  op  = 0;

    size = rom.tellg();
    mem = new uint8[size];
    rom.seekg(0, std::ios::beg);
    rom.read((char*)mem, size);
    rom.close();

    for (int i = 0; i < size; i += 2)
    {
        op1 = mem[i];
        if (i + 1 < size)
            op2 = mem[i + 1];
        else
        {
            std::cerr << "Invalid opcode, exiting." << std::endl;
            exit(1);
        }

        op = (op1 << 8) | op2;
        switch ((op & 0xF000) >> 12)
        {
            case 1:
                functions[op & 0x0FFF] = Type::ADR;
                break;
            case 2:
                functions[op & 0x0FFF] = Type::SUB;
                break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2220
movq %rax, 0x3d95(%rip)      # 0x6188
movq %rdx, 0x3d96(%rip)      # 0x6190
movq %rax, %rdi
callq 0x2030
movq %rax, 0x3d77(%rip)      # 0x6180
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21c0
movq 0x3d64(%rip), %rsi      # 0x6180
movq 0x3d65(%rip), %rdx      # 0x6188
movq %rbx, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x2060
movq 0x3d4e(%rip), %rax      # 0x6188
testq %rax, %rax
jle 0x24d8
movl $0x1, %r12d
leaq 0x3d00(%rip), %rbx      # 0x6150
leaq 0x6(%rsp), %r14
leaq 0x4(%rsp), %r15
cmpq %r12, %rax
jle 0x24e4
movq 0x3d16(%rip), %rax      # 0x6180
movzbl -0x1(%rax,%r12), %ecx
movzbl (%rax,%r12), %edx
movl %ecx, %eax
shll $0x8, %eax
orl %edx, %eax
shrl $0x4, %ecx
cmpl $0x1, %ecx
je 0x24a6
cmpl $0x2, %ecx
jne 0x24c1
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d78
movl $0x0, (%rax)
jmp 0x24c1
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0x6(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d78
movl $0x1, (%rax)
movq 0x3cc0(%rip), %rax      # 0x6188
leaq 0x2(%r12), %rcx
incq %r12
cmpq %r12, %rax
movq %rcx, %r12
jg 0x245a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x3b05(%rip), %rdi      # 0x5ff0
leaq 0x1b8e(%rip), %rsi      # 0x4080
callq 0x2140
movq %rax, %rdi
callq 0x20c0
movl $0x1, %edi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/bloody76[P]Chip8-Disassembler/src/disassembler.cc
// Function: main
int main(int argc, char** argv)
{
    if (argc < 2)
    {
        std::cerr << "First argument must be a filename." << std::endl;
        return 1;
    }
    std::string file(argv[1]);

    functions[0x200] = Type::SUB;
    std::ifstream rom(file, std::ios::ate);
    if (!rom.is_open())
    {
        std::cerr << "Fill with a valid filename." << std::endl;
        return 1;
    }
    parse(rom);
    pretty_print();
    delete[] mem;
    return 0;
}

// Assembly:
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
cmpl $0x1, %edi
jg 0x2c45
movq 0x33f0(%rip), %rbx      # 0x5ff0
leaq 0x156b(%rip), %rsi      # 0x4172
movl $0x22, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movl $0x1, %ebx
jmp 0x2d30
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdx
callq 0x2de0
movw $0x200, (%rbx)          # imm = 0x200
leaq 0x34e9(%rip), %rdi      # 0x6150
leaq 0x28(%rsp), %rsi
callq 0x2d78
movl $0x0, (%rax)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x2, %edx
callq 0x21f0
leaq 0xa0(%rsp), %rdi
callq 0x2070
testb %al, %al
je 0x2cc0
leaq 0x28(%rsp), %rdi
callq 0x23dc
callq 0x2509
movq 0x34ce(%rip), %rdi      # 0x6180
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x2d0b
callq 0x21b0
jmp 0x2d0b
movq 0x3329(%rip), %rbx      # 0x5ff0
leaq 0x14c7(%rip), %rsi      # 0x4195
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq 0x32f7(%rip), %rdi      # 0x5ff0
callq 0x2040
movl $0x1, %ebx
movq %rax, %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
callq 0x2080
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d30
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movl %ebx, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
retq
jmp 0x2d3d
movq %rax, %rbx
jmp 0x2d4f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2080
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d6a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex02/Squad.cpp
// Function: Squad::operator=(Squad const&)
Squad &Squad::operator=(Squad const &other)
{
	std::cout << "Copy" << std::endl;
	for (int i = 0; i < this->current; i++)
		delete this->units[i];
	delete []this->units;
	this->units = 0;
	this->current = 0;
	for (int i = 0; i < other.getCount(); i++)
		this->push(other.getUnit(i)->clone());
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2a85(%rip), %r15      # 0x3fd8
leaq 0xb48(%rip), %rsi       # 0x20a2
movl $0x4, %edx
movq %r15, %rdi
callq 0x10c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %r15, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1070
cmpl $0x0, 0x8(%rbx)
jle 0x15b6
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x15aa
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x1597
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x15c4
callq 0x10d0
movq $0x0, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testl %eax, %eax
jle 0x1615
xorl %r15d, %r15d
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
callq *0x18(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rcx)
incl %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl %eax, %r15d
jl 0x15e3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex02/Squad.cpp
// Function: Squad::~Squad()
Squad::~Squad(void)
{
	for (int i = 0; i < this->current; i++)
		delete this->units[i];
	delete []this->units;
	this->units = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x26db(%rip), %rax      # 0x3d10
movq %rax, (%rdi)
cmpl $0x0, 0x8(%rdi)
jle 0x1660
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x1654
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x1641
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x166e
callq 0x10d0
movq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex02/Squad.cpp
// Function: Squad::push(ISpaceMarine*)
int Squad::push(ISpaceMarine *unit)
{
	if (unit == 0)
		return (0);
	for (int i = 0; i < this->current; i++)
	{
		if (this->units[i] == unit)
			return (0);
	}
	ISpaceMarine **tmp = new ISpaceMarine*[this->current + 1];
	for (int i = 0; i < this->current; i++)
		tmp[i] = this->units[i];
	tmp[this->current++] = unit;
	if (this->units != 0)
		delete []this->units;
	this->units = tmp;
	return (1);
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0x1786
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x8(%rdi), %r12
testq %r12, %r12
setg %dl
jle 0x171a
movq 0x10(%rbx), %rcx
cmpq %r14, (%rcx)
je 0x1716
leaq -0x1(%r12), %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x171a
leaq 0x1(%rsi), %rdi
cmpq %r14, 0x8(%rcx,%rsi,8)
movq %rdi, %rsi
jne 0x16fd
cmpq %r12, %rdi
setb %dl
testb %dl, %dl
jne 0x1778
leaq 0x1(%r12), %r13
cmpl $-0x1, %r12d
leaq 0x8(,%r12,8), %rax
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x1030
movq %rax, %r15
testl %r12d, %r12d
jle 0x1759
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %r12
jne 0x1749
movl %r13d, 0x8(%rbx)
movq %r14, (%r15,%r12,8)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x176f
callq 0x10d0
movq %r15, 0x10(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex02/main.cpp
// Function: main
int main(void)
{
	ISpaceMarine* bob = new TacticalMarine;
	ISpaceMarine* jim = new AssaultTerminator;
	Squad *vlc = new Squad;
	Squad copy;
	vlc->push(bob);
	copy = *vlc;
	vlc->push(jim);
	std::cout << "--- First squad ---" << std::endl;
	for (int i = 0; i < vlc->getCount(); ++i)
	{
		ISpaceMarine* cur = vlc->getUnit(i);
		cur->battleCry();
		cur->rangedAttack();
		cur->meleeAttack();
	}
	std::cout << "--- Second squad ---" << std::endl;
	for (int i = 0; i < copy.getCount(); ++i)
	{
		ISpaceMarine* cur = copy.getUnit(i);
		cur->battleCry();
		cur->rangedAttack();
		cur->meleeAttack();
	}
	delete vlc;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl $0x8, %edi
callq 0x10a0
movq %rax, %r12
movq %rax, %rdi
callq 0x1788
movl $0x8, %edi
callq 0x10a0
movq %rax, %r14
movq %rax, %rdi
callq 0x12cc
movl $0x18, %edi
callq 0x10a0
movq %rax, %rbx
movq %rax, %rdi
callq 0x14fc
leaq -0x38(%rbp), %rdi
callq 0x14fc
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0x20(%rax)
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x153c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rax)
movq 0x25ae(%rip), %r14      # 0x3fd8
leaq 0x70a(%rip), %rsi       # 0x213b
movl $0x13, %edx
movq %r14, %rdi
callq 0x10c0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq 0x257c(%rip), %rdi      # 0x3fd8
callq 0x1040
movq %rax, %rdi
callq 0x1070
xorl %r14d, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
cmpl %eax, %r14d
jge 0x1aa9
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x18(%rax)
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
incl %r14d
jmp 0x1a6c
movq 0x2528(%rip), %r14      # 0x3fd8
leaq 0x698(%rip), %rsi       # 0x214f
movl $0x14, %edx
movq %r14, %rdi
callq 0x10c0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq 0x24f6(%rip), %rdi      # 0x3fd8
callq 0x1040
movq %rax, %rdi
callq 0x1070
xorl %r14d, %r14d
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x169e
cmpl %eax, %r14d
jge 0x1b33
movq %r15, %rdi
movl %r14d, %esi
callq 0x16a8
movq %rax, %r12
movq (%rax), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x20(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
incl %r14d
jmp 0x1af6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
leaq -0x38(%rbp), %rdi
callq 0x1624
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x18, %esi
movq %rbx, %rdi
jmp 0x1b79
movq %rax, %r15
movl $0x8, %esi
movq %r14, %rdi
jmp 0x1b79
movq %rax, %r15
movl $0x8, %esi
movq %r12, %rdi
callq 0x10b0
jmp 0x1b94
jmp 0x1b88
jmp 0x1b88
jmp 0x1b88
jmp 0x1b88
movq %rax, %r15
leaq -0x38(%rbp), %rdi
callq 0x1624
movq %r15, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O1/princelab[P]emass/emass.cpp
// Function: convolute_basic(std::vector<peak, std::allocator<peak>>&, std::vector<peak, std::allocator<peak>> const&, std::vector<peak, std::allocator<peak>> const&)
void convolute_basic(Pattern & h, const Pattern & g, const Pattern & f)
{
  h.clear();
  size_t g_n = g.size();
  size_t f_n = f.size();
  if(g_n == 0 || f_n == 0)
     return;
  for(size_t k = 0; k < g_n + f_n - 1; k++) {
    double sumweight = 0, summass = 0;
    size_t start = k < (f_n - 1) ? 0 : k - f_n + 1; // max(0, k-f_n+1)
    size_t end = k < (g_n - 1) ? k : g_n - 1;       // min(g_n - 1, k)
    for(size_t i = start; i <= end; i++) {
      double weight = g[i].rel_area * f[k - i].rel_area;
      double mass = g[i].mass + f[k - i].mass;
      sumweight += weight;
      summass += weight * mass;
    }
    peak p;
    if(sumweight == 0)
      p.mass = DUMMY_MASS;
    else
      p.mass = summass / sumweight;
    p.rel_area = sumweight;
    h.push_back(p);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x3bc9
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %r15
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rbp
subq (%rax), %rbp
sete %al
subq (%rcx), %r15
sete %cl
orb %al, %cl
jne 0x3d37
sarq $0x4, %r15
sarq $0x4, %rbp
leaq (%r15,%rbp), %r14
decq %r14
je 0x3d37
leaq -0x1(%rbp), %r13
decq %r15
movq %rbp, %r9
negq %r9
shlq $0x4, %rbp
movl $0x18, %eax
subq %rbp, %rax
movq %rax, 0x20(%rsp)
addq $-0x8, %rbp
xorl %r12d, %r12d
xorpd %xmm4, %xmm4
movsd 0x43db(%rip), %xmm5     # 0x8010
movq %rbx, 0x18(%rsp)
cmpq %r13, %r12
movq %r13, %rax
cmovaq %r12, %rax
leaq 0x1(%r12,%r9), %rcx
movl $0x0, %edx
cmovaeq %rcx, %rdx
cmpq %r15, %r12
movq %r15, %rcx
cmovbq %r12, %rcx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
ja 0x3cbf
leaq (%r9,%rax), %rdx
shlq $0x4, %rax
movq 0x10(%rsp), %rsi
movq (%rsi), %rsi
addq %rbp, %rsi
movq 0x8(%rsp), %rdi
movq (%rdi), %rdi
addq 0x20(%rsp), %rdi
addq %rax, %rdi
negq %rax
movsd -0x8(%rdi), %xmm2
movsd (%rdi), %xmm3
mulsd (%rsi,%rax), %xmm3
addsd -0x8(%rsi,%rax), %xmm2
addsd %xmm3, %xmm0
mulsd %xmm3, %xmm2
addsd %xmm2, %xmm1
incq %rdx
addq $-0x10, %rsi
addq $0x10, %rdi
cmpq %rcx, %rdx
jb 0x3c8f
divsd %xmm0, %xmm1
movapd %xmm0, %xmm2
cmpeqsd %xmm4, %xmm2
movapd %xmm2, %xmm3
andnpd %xmm1, %xmm3
andpd %xmm5, %xmm2
orpd %xmm3, %xmm2
movlpd %xmm2, 0x28(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3d03
movupd 0x28(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x3d27
movq %rbx, %rdi
leaq 0x28(%rsp), %rdx
movq %r9, %rbx
callq 0x53ec
movsd 0x42f5(%rip), %xmm5     # 0x8010
xorpd %xmm4, %xmm4
movq %rbx, %r9
movq 0x18(%rsp), %rbx
incq %r12
addq $0x10, %rbp
cmpq %r14, %r12
jne 0x3c3a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/princelab[P]emass/emass.cpp
// Function: prune(std::vector<peak, std::allocator<peak>>&, double)
void prune(Pattern & f, double limit)
{
  // prune the front
  Pattern::iterator i = f.begin();
  while(i != f.end()) {
    if((*i).rel_area > limit)
      break;
    i++;
  }
  f.erase(f.begin(), i);

  // prune the end
  while(1) {
    if(f.size() == 0)
      break;
    if(f.back().rel_area > limit)
      break;
    f.pop_back();
  } 
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rdx
movq %r14, %r15
cmpq %rdx, %r14
je 0x3d79
movq %r14, %r15
movsd 0x8(%r15), %xmm1
ucomisd %xmm0, %xmm1
ja 0x3d79
addq $0x10, %r15
cmpq %rdx, %r15
jne 0x3d64
cmpq %r14, %r15
je 0x3db0
subq %r15, %rdx
je 0x3d9a
movq %r14, %rdi
movq %r15, %rsi
movsd %xmm0, 0x8(%rsp)
callq 0x3400
movsd 0x8(%rsp), %xmm0
movq 0x8(%rbx), %rax
movq %rax, %rcx
subq %r15, %rcx
addq %rcx, %r14
cmpq %r14, %rax
je 0x3db0
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
je 0x3dd1
movsd -0x8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
ja 0x3dd1
addq $-0x10, %rcx
movq %rcx, 0x8(%rbx)
jmp 0x3db7
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/princelab[P]emass/emass.cpp
// Function: print_pattern(std::vector<peak, std::allocator<peak>>&, int)
void print_pattern(Pattern & result, int digits)
{
  // find the maximum
  double max_area = 0;
  double sum_area = 0;
  for(Pattern::iterator i = result.begin(); i != result.end(); ++i) {
    if(max_area < (*i).rel_area)
      max_area = (*i).rel_area;
    sum_area += (*i).rel_area;
  }
  if(max_area == 0)
    return; // empty pattern

  wcout.setf(ios::fixed);
  wcout.precision(digits);
  double print_limit = pow(10.0, -digits) / 2;
  //wcout.precision(30);
  //double print_limit = 0.000001 / 2;
  for(Pattern::iterator i = result.begin(); i != result.end(); ++i) {
    double mass = (*i).mass;
    double rel_area = (*i).rel_area;
    double val_perc = rel_area / max_area * 100;
    //double val_norm = rel_area / sum_area;
    if(mass != DUMMY_MASS && val_perc >= print_limit)
      wcout << mass << L" " << val_perc << endl;
    //wcout << mass << L" " << val_perc << L" " << val_norm << endl;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
cmpq %rcx, %rax
je 0x3e19
xorpd %xmm1, %xmm1
movsd 0x8(%rax), %xmm2
maxsd %xmm1, %xmm2
addq $0x10, %rax
movapd %xmm2, %xmm1
cmpq %rcx, %rax
jne 0x3e03
ucomisd %xmm0, %xmm2
jne 0x3e25
jnp 0x3f5a
movq 0x719c(%rip), %rax      # 0xafc8
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
orl $0x4, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movslq %esi, %rdx
movq %rdx, 0x8(%rax,%rcx)
negl %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
movsd 0x41c3(%rip), %xmm0     # 0x8018
movsd %xmm2, 0x10(%rsp)
callq 0x3450
movsd 0x10(%rsp), %xmm1
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %r13
cmpq 0x8(%rbx), %r13
je 0x3f5a
movsd 0x8(%rsp), %xmm0
mulsd 0x4199(%rip), %xmm0     # 0x8020
movsd %xmm0, 0x8(%rsp)
movsd 0x4193(%rip), %xmm2     # 0x8028
movsd 0x4173(%rip), %xmm3     # 0x8010
movq 0x7124(%rip), %r14      # 0xafc8
leaq 0x41f1(%rip), %r15      # 0x809c
movsd (%r13), %xmm0
movsd 0x8(%r13), %xmm4
divsd %xmm1, %xmm4
mulsd %xmm2, %xmm4
ucomisd %xmm3, %xmm0
jne 0x3ecb
jnp 0x3f4c
ucomisd 0x8(%rsp), %xmm4
jb 0x3f4c
movq %r14, %rdi
movsd %xmm4, 0x18(%rsp)
callq 0x3460
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x30e0
movq %r12, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x3460
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rax
movq 0xf0(%r12,%rax), %rdi
testq %rdi, %rdi
je 0x3f68
movq (%rdi), %rax
movl $0xa, %esi
callq *0x50(%rax)
movq %r12, %rdi
movl %eax, %esi
callq 0x3270
movq %rax, %rdi
callq 0x3390
movsd 0x10(%rsp), %xmm1
movsd 0x40e4(%rip), %xmm2     # 0x8028
movsd 0x40c4(%rip), %xmm3     # 0x8010
addq $0x10, %r13
cmpq 0x8(%rbx), %r13
jne 0x3eab
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/princelab[P]emass/parser.cpp
// Function: Parser::parse_formula(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
void Parser::parse_formula(const wstring & frml)
{
  _tokenizer.set_input(frml);
  _tokenizer.get_token();
  Parser::ElementListNode * tmp = parse();
  
  if(_tokenizer._ttype != EOS) {
    delete tmp; 
    _tokenizer.error(L"End of input expected");
  }
  delete tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq $0x0, 0x30(%rdi)
leaq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x33c0
movq 0x58b3(%rip), %rsi      # 0xb370
movq 0x58b4(%rip), %rdx      # 0xb378
movq %r15, %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x5b96
movq %r14, %rdi
callq 0x5e5a
cmpl $0x2, 0x8(%r14)
jne 0x5b04
testq %rax, %rax
je 0x5afa
movq (%rax), %rcx
movq %rax, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rcx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
testq %rax, %rax
je 0x5b12
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x268a(%rip), %rsi      # 0x81ac
leaq 0x26d7(%rip), %rdx      # 0x8200
movq %rsp, %r14
movq %r14, %rdi
callq 0x68c6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x610c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5b5d
movq 0x10(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O1/princelab[P]emass/parser.cpp
// Function: Parser::Tokenizer::error(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>)
void Parser::Tokenizer::error(wstring msg)
{
  msg += L":\n";
  _input.resize(_input.length() - ENDTOKEN.length());
  msg += _input + L"\n";
  msg += wstring(_last, L' ') + L"^\n";
  throw Parser::Error(msg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x21b3(%rip), %rsi      # 0x82d8
movq %rbx, %rdi
callq 0x34b0
leaq 0x38(%r14), %rdi
movq 0x40(%r14), %rsi
subq 0x523c(%rip), %rsi      # 0xb378
xorl %edx, %edx
callq 0x34c0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rax
leaq (%rsi,%rax,4), %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x4ce6
leaq 0x2171(%rip), %rsi      # 0x82dc
movq %r15, %rdi
callq 0x34b0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3320
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x619f
movq 0x10(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x32f0
movq 0x30(%r14), %rsi
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x20(%rsp), %rdi
movl $0x20, %edx
callq 0x34e0
leaq 0x2122(%rip), %rsi      # 0x82e4
leaq 0x20(%rsp), %rdi
callq 0x34b0
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3500
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x3320
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6204
movq 0x10(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x32f0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x6220
movq 0x30(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x32f0
movl $0x20, %edi
callq 0x3130
movq %rax, %r14
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
leaq (%rsi,%rax,4), %rdx
leaq 0x40(%rsp), %rdi
callq 0x4ce6
movq %r14, %rax
addq $0x10, %rax
movq %rax, (%r14)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rax
leaq (%rsi,%rax,4), %rdx
movb $0x1, %bpl
movq %r14, %rdi
callq 0x4ce6
xorl %ebp, %ebp
leaq 0x4a79(%rip), %rsi      # 0xacf0
leaq 0x2fc(%rip), %rdx       # 0x657a
movq %r14, %rdi
callq 0x3440
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x62ad
movq 0x50(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x32f0
jmp 0x62ad
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6315
movq %r14, %rdi
callq 0x31d0
jmp 0x6315
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x62df
movq 0x10(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x32f0
jmp 0x62df
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x6315
movq 0x30(%rsp), %rax
jmp 0x6308
movq %rax, %rbx
jmp 0x6315
jmp 0x62f7
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6315
movq 0x10(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O1/princelab[P]emass/parser.cpp
// Function: Parser::write_compound(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, std::map<unsigned long, long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, long>>>&)
void Parser::write_compound(const wstring & frml, FormMap & c)
{
  c.clear();

  _tokenizer.set_input(frml);
  _tokenizer.get_token();
  Parser::ElementListNode * tmp = parse();
  
  if(_tokenizer._ttype != EOS) {
    delete tmp;	
    _tokenizer.error(L"End of input expected");
  }

  tmp->fill_compound(1, c);
  cleanUpFormula(c);
  delete tmp;	
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rdi
callq 0x5908
leaq 0x8(%r15), %rbx
movq $0x0, 0x30(%r15)
leaq 0x40(%r15), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x33c0
movq 0x5012(%rip), %rsi      # 0xb370
movq 0x5013(%rip), %rdx      # 0xb378
movq %r13, %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x5b96
movq %r15, %rdi
callq 0x5e5a
movq %rax, %r12
cmpl $0x2, 0x8(%r15)
jne 0x63b8
movq (%r12), %rax
movl $0x1, %esi
movq %r12, %rdi
movq %r14, %rdx
callq *0x10(%rax)
movq %r14, %rdi
callq 0x69e8
movq (%r12), %rax
movq %r12, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x8(%rax)
testq %r12, %r12
je 0x63c7
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1dd5(%rip), %rsi      # 0x81ac
leaq 0x1e22(%rip), %rdx      # 0x8200
movq %rsp, %r14
movq %r14, %rdi
callq 0x68c6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x610c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6412
movq 0x10(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/princelab[P]emass/parser.cpp
// Function: Parser::ElementListNode::~ElementListNode()
Parser::ElementListNode::~ElementListNode()
{
  for(NodeList::iterator i = _NodeList.begin();
      i != _NodeList.end();
      ++i)
    {
      delete *i;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4844(%rip), %rax      # 0xad10
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x64f0
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x64eb
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %r14
jmp 0x64d7
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x650d
movq (%rdi), %r14
movl $0x18, %esi
callq 0x32f0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x64f8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/princelab[P]emass/parser.cpp
// Function: Parser::ElementListNode::fill_compound(unsigned long, std::map<unsigned long, long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, long>>>&) const
void Parser::ElementListNode::fill_compound(ulong weight, FormMap & c) const
{
  ulong totalweight = _count * weight;
  
  for(NodeList::const_iterator i = _NodeList.begin();
      i != _NodeList.end();
      ++i)
    {
      (*i)->fill_compound(totalweight, c);
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r15, %r12
je 0x6568
movq %rdx, %rbx
movq %rsi, %r14
imulq 0x20(%rdi), %r14
movq 0x10(%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq (%r12), %r12
cmpq %r15, %r12
jne 0x654e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/princelab[P]emass/formula.cpp
// Function: cleanUpFormula(std::map<unsigned long, long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, long>>>&)
void cleanUpFormula(FormMap & form) {
  
  typedef std::vector<size_t> Erasable;

  Erasable e;
  for(FormMap::iterator i = form.begin(); i != form.end(); ++i)
    if(i->second == 0)
      e.push_back(i->first);

  for(Erasable::iterator i = e.begin(); i != e.end(); ++i)
      form.erase(*i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rdi), %r14
leaq 0x8(%rdi), %r12
cmpq %r12, %r14
je 0x6a56
movq %rsp, %r15
cmpq $0x0, 0x28(%r14)
jne 0x6a46
leaq 0x20(%r14), %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x6a3e
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x6a46
movq %r15, %rdi
callq 0x6d5c
movq %r14, %rdi
callq 0x31b0
movq %rax, %r14
cmpq %r12, %rax
jne 0x6a16
movq (%rsp), %r14
cmpq 0x8(%rsp), %r14
je 0x6a7d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e98
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6f14
addq $0x8, %r14
jmp 0x6a5a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6a93
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32f0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x6aa1
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6aba
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/princelab[P]emass/formula.cpp
// Function: isRealFormula(std::map<unsigned long, long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, long>>> const&)
bool isRealFormula(const FormMap & form) {
  for(FormMap::const_iterator i = form.begin(); i != form.end(); ++i) {
    if(i->second < 0)
      return false;
  }
  return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq $0x8, %rbx
cmpq %rbx, %rax
sete %cl
je 0x6bc0
cmpq $0x0, 0x28(%rax)
js 0x6bc0
movq %rax, %rdi
callq 0x3340
jmp 0x6ba7
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/BleuLlama[P]msf-tools/msf-dump.cpp
// Function: usage(char*)
void usage( char * av0 )
{
	std::cout << "Usage:  " << av0 << std::endl;
	std::cout << std::endl;
	std::cout << "note: define VOICERECORDER env var to set root path." << std::endl;
	std::cout << "  eg:" << std::endl;
	std::cout << "      export VOICERECORDER=/Volumes/IC_RECORDER" << std::endl;
	std::cout << "      export VOICERECORDER=/v/" << std::endl;
	std::cout << "      export VOICERECORDER=v:\\" << std::endl;

	std::cout << std::endl;
	std::cout << "Version 1.0  yorgle@gmail.com  Scott Lawrence" << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x2f1a(%rip), %rbx      # 0x6fd0
leaq 0x114f(%rip), %rsi      # 0x520c
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2130
testq %r14, %r14
je 0x40eb
movq %r14, %rdi
callq 0x2070
movq 0x2ef2(%rip), %rdi      # 0x6fd0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2130
jmp 0x4102
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2200
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x10be(%rip), %rsi      # 0x5215
movl $0x34, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x10b8(%rip), %rsi      # 0x524a
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x1083(%rip), %rsi      # 0x5250
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x1078(%rip), %rsi      # 0x5280
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x105c(%rip), %rsi      # 0x529f
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x1019(%rip), %rsi      # 0x52be
movl $0x2d, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O1/BleuLlama[P]msf-tools/msf-dump.cpp
// Function: main
int main( int argc, char ** argv )
{
	char * pth;

	pth = getenv( "VOICERECORDER" );
	if( !pth ) {
		usage( argv[0] );
		return -1;
	}

	// NOTE: on windows, put in a scan for a drive with label "IC_RECORDER"

	VoiceFile vf( pth );
	if( !vf.Valid() ) {
		std::cerr << "Directory is invalid: " << pth << std::endl;
		return -2;
	}

	int ret = vf.Dump();

	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
leaq 0xff6(%rip), %rdi       # 0x52ec
callq 0x2160
testq %rax, %rax
je 0x4360
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, %rdi
callq 0x2070
movq %rbx, %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d1a
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x2dac
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x434b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2110
cmpb $0x0, 0x20(%rsp)
je 0x436f
leaq 0x20(%rsp), %rdi
callq 0x329a
movl %eax, %ebx
jmp 0x43d4
movq (%r14), %rdi
callq 0x40a8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x43de
movq 0x2c7a(%rip), %rdi      # 0x6ff0
leaq 0xf7d(%rip), %rsi       # 0x52fa
movl $0x16, %edx
callq 0x2130
movq %rbx, %rdi
callq 0x2070
movq 0x2c5a(%rip), %r14      # 0x6ff0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2130
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq 0x2c2e(%rip), %rdi      # 0x6ff0
callq 0x2040
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movq %rax, %rdi
callq 0x20a0
leaq 0x20(%rsp), %rdi
callq 0x3234
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x440a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4417
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2110
jmp 0x4417
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3234
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/thread_x.c
// Function: diag
static void
diag(char const*fmt, ...) 
{
    va_list     ap;
    va_start(ap, fmt);
    fprintf(stderr, "%.6f ", tick() - start);
    vfprintf(stderr, fmt, ap);
    putc('\n', stderr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x34a6
movapd %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x5b13(%rip), %r12      # 0x8fe0
movq (%r12), %r15
callq 0x4942
subsd 0x62fa(%rip), %xmm0     # 0x97d8
leaq 0x2c1d(%rip), %rsi      # 0x6102
movq %r15, %rdi
movb $0x1, %al
callq 0x3310
movq (%r12), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x32d0
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x33f0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/thread_x.c
// Function: sleeping
static void*
sleeping(void *arg)
{
    (void)arg;
    diag("\tsleeping thread starts");
    TRY(sleep(1));
    diag("\tNOTREACHED");
    return arg;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2c33(%rip), %rdi      # 0x6157
xorl %eax, %eax
callq 0x3440
leaq 0x2bee(%rip), %rdi      # 0x6120
xorl %eax, %eax
callq 0x3440
pushq $0x1
popq %rdi
callq 0x3150
leaq 0x2c27(%rip), %rdi      # 0x616f
xorl %eax, %eax
callq 0x3440
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/thread_x.c
// Function: main
int main(void)
{
    start = tick();
    setvbuf(stderr, NULL, _IOLBF, 0);

    FLAG   *flag = flag_create();
    THREAD *thrd = thread_start(flagging, flag);

    int rc;
#undef  TRY
#define TRY(x) diag(#x " ...\n"); rc = (intptr_t)(x); diag(#x ": %d %s", rc, errname[errno])
    TRY(flag_watch(flag, 0));
    TRY(flag_watch(flag, 0.5));
    TRY(flag_watch(flag, 0.5));
    TRY(sleep(1));

    thread_result(thrd);

    thrd = thread_start(sleeping, flag);
    TRY(thread_cancel(thrd));
    TRY(thread_result(thrd));

    flag_destroy(flag);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x4942
movsd %xmm0, 0x60f4(%rip)     # 0x97d8
movq 0x58f5(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3040
callq 0x4974
movq %rax, %rbx
leaq 0x17b(%rip), %rdi       # 0x3886
movq %rax, %rsi
callq 0x4ad1
movq %rax, %r15
leaq 0x28f3(%rip), %rdi      # 0x6010
xorl %eax, %eax
callq 0x3440
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x49ca
movl %eax, %ebp
callq 0x3050
movq %rax, %r14
movslq (%rax), %rax
leaq 0x5aed(%rip), %rcx      # 0x9230
movq (%rcx,%rax,8), %rdx
movq %rcx, %r13
leaq 0x28d8(%rip), %rdi      # 0x6029
movl %ebp, %esi
xorl %eax, %eax
callq 0x3440
leaq 0x28e3(%rip), %r12      # 0x6044
movq %r12, %rdi
xorl %eax, %eax
callq 0x3440
movsd 0x2895(%rip), %xmm0     # 0x6008
movq %rbx, %rdi
callq 0x49ca
movslq (%r14), %rcx
movq %r13, %rbp
movq (%r13,%rcx,8), %rdx
leaq 0x28d2(%rip), %r13      # 0x605f
movq %r13, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x3440
movq %r12, %rdi
xorl %eax, %eax
callq 0x3440
movq %rbx, %rdi
movsd 0x285a(%rip), %xmm0     # 0x6008
callq 0x49ca
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
movq %r13, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x3440
leaq 0x28ae(%rip), %rdi      # 0x607c
xorl %eax, %eax
callq 0x3440
movl $0x1, %edi
callq 0x3150
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
leaq 0x289c(%rip), %rdi      # 0x608a
movl %eax, %esi
xorl %eax, %eax
callq 0x3440
movq %r15, %rdi
callq 0x4b44
leaq -0x2ed(%rip), %rdi      # 0x3519
movq %rbx, %rsi
callq 0x4ad1
movq %rax, %r15
leaq 0x2882(%rip), %rdi      # 0x609a
xorl %eax, %eax
callq 0x3440
movq %r15, %rdi
callq 0x4b2a
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
leaq 0x287d(%rip), %rdi      # 0x60b3
movl %eax, %esi
xorl %eax, %eax
callq 0x3440
leaq 0x2888(%rip), %rdi      # 0x60ce
xorl %eax, %eax
callq 0x3440
movq %r15, %rdi
callq 0x4b44
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
leaq 0x2883(%rip), %rdi      # 0x60e7
movl %eax, %esi
xorl %eax, %eax
callq 0x3440
movq %rbx, %rdi
callq 0x499f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/thread_x.c
// Function: flagging
static void*
flagging(void *_flag)
{
    FLAG    *flag = _flag;

    diag("\tflagging thread starts", flag);
    TRY(sleep(1));
    TRY(flag_any(flag));
    TRY(flag_all(flag));
    
    diag("\tthread exit");
    return _flag;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2877(%rip), %rdi      # 0x6108
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3440
leaq 0x287e(%rip), %rdi      # 0x6120
xorl %eax, %eax
callq 0x3440
movl $0x1, %edi
callq 0x3150
leaq 0x2870(%rip), %rdi      # 0x612a
xorl %eax, %eax
callq 0x3440
movq %rbx, %rdi
callq 0x49c0
leaq 0x286a(%rip), %rdi      # 0x613a
xorl %eax, %eax
callq 0x3440
movq %rbx, %rdi
callq 0x49c5
leaq 0x2864(%rip), %rdi      # 0x614a
xorl %eax, %eax
callq 0x3440
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/thread.c
// Function: flag_destroy
void
flag_destroy(FLAG *flag)
{
    if (!flag) return;
    pthread_cond_destroy(&flag->cond);
    pthread_mutex_destroy(&flag->lock);
    free(flag);
}

// Assembly:
testq %rdi, %rdi
je 0x49bf
pushq %rbx
movq %rdi, %rbx
callq 0x3400
leaq 0x30(%rbx), %rdi
callq 0x3240
movq %rbx, %rdi
popq %rbx
jmp 0x3270
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/thread.c
// Function: flag_watch
int
flag_watch(FLAG *flag, double waitsecs)
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    waitsecs += tv.tv_sec + 1E-6*tv.tv_usec;

    struct timespec ts;
    ts.tv_sec = floor(waitsecs);
    ts.tv_nsec = (waitsecs - ts.tv_sec) * 1E9;

    pthread_mutex_lock(&flag->lock);
    errno = pthread_cond_timedwait(&flag->cond, &flag->lock, &ts);
    pthread_mutex_unlock(&flag->lock);

    return -!!errno;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3360
cvtsi2sdq (%r15), %xmm1
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%r15), %xmm0
mulsd 0x1d52(%rip), %xmm0     # 0x6758
addsd %xmm1, %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x33a0
cvttsd2si %xmm0, %rax
leaq 0x10(%rsp), %r15
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq %rax, (%r15)
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x1d3e(%rip), %xmm1     # 0x6780
cvttsd2si %xmm1, %rax
movq %rax, 0x8(%r15)
leaq 0x30(%r14), %r12
movq %r12, %rdi
callq 0x3340
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3350
movl %eax, %ebp
callq 0x3050
movq %rax, %r14
movl %ebp, (%rax)
movq %r12, %rdi
callq 0x3160
cmpl (%r14), %ebx
sbbl %ebx, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/thread.c
// Function: thread_start
THREAD*
thread_start(THREAD_FN func, void*arg)
{
    THREAD ret;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    errno = pthread_create(&ret.tid, &attr, func, arg);
    return errno ? NULL : memcpy(malloc(sizeof ret), &ret, sizeof ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3290
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x33c0
movl %eax, %ebx
callq 0x3050
movl %ebx, (%rax)
testl %ebx, %ebx
je 0x4b0f
xorl %eax, %eax
jmp 0x4b20
movl $0x8, %edi
callq 0x32c0
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/thread.c
// Function: thread_result
void*
thread_result(THREAD *pth)
{
    void *ret = NULL;
    errno = pthread_join(pth->tid, &ret); // EDEADLK...
    free(pth);
    return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq (%rdi), %rdi
movq %r14, %rsi
callq 0x31b0
movl %eax, %ebp
callq 0x3050
movl %ebp, (%rax)
movq %rbx, %rdi
callq 0x3270
movq (%r14), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/infodisk.cc
// Function: main
int main(int argc, char *argv[])
{
#if 0
  if (argc<2) { 
    usage();
    exit(-1);
  }
#endif

  DiskSystem disk(argv[1]);
  
  cerr << "Disk is as follows.\n" << disk << "\n";

  cerr << "Done.\n";

  return 0;
}

// Assembly:
pushq %rbx
subq $0xb0, %rsp
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x25be
subq $0x8, %rsp
xorl %eax, %eax
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x268c
addq $0x20, %rsp
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2519
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x5ad0(%rip), %rdi      # 0x7ff0
leaq 0x2af7(%rip), %rsi      # 0x501e
movl $0x14, %edx
callq 0x21d0
movq 0x5ab8(%rip), %rsi      # 0x7ff0
leaq 0x30(%rsp), %rdi
callq 0x3a0c
leaq 0x2cb3(%rip), %rsi      # 0x51fc
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x5a93(%rip), %rdi      # 0x7ff0
leaq 0x2acf(%rip), %rsi      # 0x5033
movl $0x6, %edx
callq 0x21d0
leaq 0x30(%rsp), %rdi
callq 0x2c2c
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25b5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x25b5
movq %rax, %rbx
jmp 0x25b5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2c2c
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/andresziemecki[P]MQTT/mqtt.cpp
// Function: ParametrosDelSimClient::ParametrosDelSimClient(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, int, int, bool, unsigned int)
ParametrosDelSimClient::ParametrosDelSimClient(TopicName TN,bool s=false, int TV=0, int e=0, bool r=false, unsigned int t=10){
    topic_name=TN;
    subscriptor=s;
    topic_value=TV;
    error = e;
    retain = r;
    time_conection = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x2c(%rbp)
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x3120
movl 0x10(%rbp), %eax
movb %r13b, 0x20(%rbx)
movl %r12d, 0x24(%rbx)
movl %r15d, 0x28(%rbx)
movl -0x2c(%rbp), %ecx
movb %cl, 0x2c(%rbx)
movl %eax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x34d9
callq 0x31c0
movq %r15, %rdi
callq 0x32e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/andresziemecki[P]MQTT/mqtt.cpp
// Function: ParametrosDelSimClient::ParametrosDelSimClient(ParametrosDelSimClient const&)
ParametrosDelSimClient::ParametrosDelSimClient(const ParametrosDelSimClient &A){
    topic_name = A.topic_name;
    subscriptor = A.subscriptor;
    topic_value = A.topic_value;
    error=A.error;
    retain=A.retain;
    time_conection=A.time_conection;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x3120
movb 0x20(%r14), %al
movb %al, 0x20(%rbx)
movl 0x24(%r14), %eax
movl %eax, 0x24(%rbx)
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movb 0x2c(%r14), %al
movb %al, 0x2c(%rbx)
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3548
callq 0x31c0
movq %r14, %rdi
callq 0x32e0