LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ddu1[P]polarizedtext/src/main.cc
// Function: printVectors(int, char**)
void printVectors(int argc, char** argv) {
  if (argc != 3) {
    printPrintVectorsUsage();
    exit(EXIT_FAILURE);
  }
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  fasttext.printVectors();
  exit(0);
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
cmpl $0x3, %edi
jne 0x106c8
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq 0x10(%rsi), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4860
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xcabc
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x106b7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x30(%rsp), %rdi
callq 0xdf0c
xorl %edi, %edi
callq 0x32b0
callq 0x10194
movl $0x1, %edi
callq 0x32b0
jmp 0x106f9
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x106fc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x106fc
movq %rax, %rbx
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1070b
callq 0x7832
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1071a
callq 0x7832
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x10729
callq 0x7832
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x10738
callq 0x7832
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x10747
callq 0x7832
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/ddu1[P]polarizedtext/src/main.cc
// Function: main
int main(int argc, char** argv) {
  if (argc < 2) {
    printUsage();
    exit(EXIT_FAILURE);
  }
  std::string command(argv[1]);
  if (command == "skipgram" || command == "cbow" || command == "supervised" || command == "pwv") {
    train(argc, argv);
  } else if (command == "test") {
    test(argc, argv);
  } else if (command == "print-vectors") {
    printVectors(argc, argv);
  } else if (command == "predict" || command == "predict-prob" ) {
    predict(argc, argv);
  } else {
    printUsage();
    exit(EXIT_FAILURE);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x1, %edi
jle 0x1093c
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x4860
leaq 0x1be8(%rip), %rsi      # 0x124a9
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x1090c
leaq 0x785(%rip), %rsi       # 0x11059
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
je 0x1090c
leaq 0x761(%rip), %rsi       # 0x1104a
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
je 0x1090c
leaq 0x757(%rip), %rsi       # 0x11055
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
jne 0x1094b
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1074f
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10931
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xffb0
movl $0x1, %edi
callq 0x32b0
leaq 0x756(%rip), %rsi       # 0x110a8
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
jne 0x1096a
movl %ebp, %edi
movq %rbx, %rsi
callq 0x101ec
leaq 0x1b41(%rip), %rsi      # 0x124b2
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
jne 0x10989
movl %ebp, %edi
movq %rbx, %rsi
callq 0x10651
leaq 0x1b30(%rip), %rsi      # 0x124c0
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
je 0x109b3
leaq 0x1af7(%rip), %rsi      # 0x1249c
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
jne 0x109bd
movl %ebp, %edi
movq %rbx, %rsi
callq 0x103f5
callq 0xffb0
jmp 0x10941
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x109e5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]brain-tools/src/smartvio-brain.cpp
// Function: dumpDNA(int, unsigned short, unsigned char*)
int dumpDNA (int i2c_file, uint16_t port_addr, uint8_t *data)
{
	uint16_t dna_length;

	if (i2cRead(i2c_file, port_addr, 0x8000, 2, 2, (uint8_t *)&dna_length) != 0) {
		return -1;
	}

	if (dna_length > 1318) {
		printf("Invalid DNA Length\n");
		exit(EXIT_FAILURE);
	}

	if (readMCU(i2c_file, port_addr, 0x8000, data, dna_length) != 0) {
		return -1;
	}

	return dna_length;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %ebp
leaq 0x6(%rsp), %r9
movl $0x8000, %edx           # imm = 0x8000
movl $0x2, %ecx
movl $0x2, %r8d
callq 0x360a
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x37ee
movzwl 0x6(%rsp), %r15d
cmpl $0x527, %r15d           # imm = 0x527
jae 0x37f9
movzwl %r14w, %esi
movl %ebp, %edi
movl $0x8000, %edx           # imm = 0x8000
movq %rbx, %rcx
movl %r15d, %r8d
callq 0x3712
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x679c(%rip), %rdi      # 0x9f9c
callq 0x3310
movl $0x1, %edi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]brain-tools/src/smartvio-brain.cpp
// Function: readDNA(int, unsigned int*, unsigned int*)
int readDNA (int i2c_file, uint32_t *svio1, uint32_t *svio2)
{
	uint8_t i;
	int vmin;
	uint8_t dna_buf[64];

	for (i = 0; i < SVIO_NUM_PORTS; i++) {
		// Skip ports referring to the FPGA
		if (0x00 == svio.ports[i].i2c_addr) {
			continue;
		}

		if (i2cDetect(i2c_file, svio.ports[i].i2c_addr) != 0) {
			// Device is not present
			continue;
		}

		// Read the full DNA Header
		if (readMCU(i2c_file, svio.ports[i].i2c_addr, 0x8000, dna_buf,
		            SZG_DNA_HEADER_LENGTH_V1) != 0) {
			return -1;
		}

		if (szgParsePortDNA(i, &svio, dna_buf, SZG_DNA_HEADER_LENGTH_V1) != 0) {
			return -1;
		}

		if (svio.ports[i].attr & SZG_ATTR_LVDS) {
			switch (svio.ports[i].group) {
				case 0:
					svio.ports[0].ranges[0].min = 250;
					svio.ports[0].ranges[0].max = 250;
					break;
				case 1:
					svio.ports[2].ranges[0].min = 250;
					svio.ports[2].ranges[0].max = 250;
					break;
			}
		}
	}

	// Find a solution
	for (i = 0; i < SVIO_NUM_GROUPS; i++) {
		vmin = szgSolveSmartVIOGroup(svio.ports, svio.group_masks[i]);
		if (vmin > 0) {
			svio.svio_results[i] = vmin;
		}
	}

	*svio1 = svio.svio_results[0];
	*svio2 = svio.svio_results[1];

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, (%rsp)
movl %edi, %ebp
leaq 0xa9f1(%rip), %r14      # 0xe220
xorl %r12d, %r12d
leaq 0x10(%rsp), %r13
leaq 0xa9ca(%rip), %r15      # 0xe208
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl (%r14), %esi
testl %esi, %esi
je 0x38ce
movl %ebp, %edi
callq 0x350c
testl %eax, %eax
jne 0x38ce
movzwl (%r14), %esi
movl %ebp, %edi
movl $0x8000, %edx           # imm = 0x8000
movq %r13, %rcx
movl $0x28, %r8d
callq 0x3712
testl %eax, %eax
jne 0x392e
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
movl $0x28, %ecx
callq 0x7f60
testl %eax, %eax
jne 0x392e
testb $0x1, 0x14(%r14)
je 0x38ce
movl 0x8(%r14), %edx
leaq 0xa99d(%rip), %rax      # 0xe244
leaq 0xa99a(%rip), %rcx      # 0xe248
testl %edx, %edx
je 0x38c5
cmpl $0x1, %edx
jne 0x38ce
leaq 0xaa5e(%rip), %rax      # 0xe31c
leaq 0xaa5b(%rip), %rcx      # 0xe320
movl $0xfa, %edx
movl %edx, (%rax)
movl %edx, (%rcx)
incq %r12
addq $0x6c, %r14
cmpq $0x6, %r12
jne 0x3843
movb $0x1, %bpl
xorl %r14d, %r14d
leaq 0xa934(%rip), %r12      # 0xe220
xorl %ebx, %ebx
movl 0x10(%r15,%r14,4), %esi
movq %r12, %rdi
callq 0x808b
testl %eax, %eax
jle 0x3904
movl %eax, 0x8(%r15,%r14,4)
movl $0x1, %r14d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x38ee
movl 0xa8f5(%rip), %eax      # 0xe210
movq (%rsp), %rcx
movl %eax, (%rcx)
movl 0xa8ed(%rip), %eax      # 0xe214
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]brain-tools/src/smartvio-brain.cpp
// Function: applyVIO(int, unsigned int, unsigned int)
int applyVIO (int i2c_file, uint32_t svio1, uint32_t svio2)
{
	uint8_t temp_data[2];
	
	// Bounds check to be sure that everything is good to go
	if ((svio1 != 0) && ((svio1 < 120) || (svio1 > 330))) {
		printf("Invalid SmartVIO solution\n");
		exit(EXIT_FAILURE);
	}
	if ((svio2 != 0) && ((svio2 < 120) || (svio2 > 330))) {
		printf("Invalid SmartVIO solution\n");
		exit(EXIT_FAILURE);
	}

	// Disable write protect on TPS65400
	temp_data[0] = 0x20;
	if (i2cWrite(i2c_file, 0x6a, 0x10, 1, 1, temp_data) != 0) {
		return -1;
	}

	// TPS65400 VREF = VOUT * 531 - 60
	if (svio1 != 0) {
		printf("Setting VIO1 to: %d\n", svio1);
		temp_data[0] = 0x0;
		if (i2cWrite(i2c_file, 0x6a, 0x00, 1, 1, temp_data) != 0) {
			return -1;
		}
		temp_data[0] = svio1 * 531 / 1000 - 60;
		if (i2cWrite(i2c_file, 0x6a, 0xd8, 1, 1, temp_data) != 0) {
			return -1;
		}
	}
	if (svio2 != 0) {
		printf("Setting VIO2 to: %d\n", svio2);
		temp_data[0] = 0x1;
		if (i2cWrite(i2c_file, 0x6a, 0x00, 1, 1, temp_data) != 0) {
			return -1;
		}
		temp_data[0] = svio2 * 531 / 1000 - 60;
		if (i2cWrite(i2c_file, 0x6a, 0xd8, 1, 1, temp_data) != 0) {
			return -1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
testl %esi, %esi
sete %al
leal -0x14b(%r15), %ecx
cmpl $0xffffff2d, %ecx       # imm = 0xFFFFFF2D
setae %cl
orb %al, %cl
je 0x3ac4
movl %edx, %r14d
testl %edx, %edx
sete %al
leal -0x14b(%r14), %ecx
cmpl $0xffffff2d, %ecx       # imm = 0xFFFFFF2D
setae %cl
orb %al, %cl
je 0x3ac4
movl %edi, %ebx
leaq 0x6(%rsp), %r9
movb $0x20, (%r9)
movl $0x6a, %esi
movl $0x10, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x3554
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x39c1
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testl %r15d, %r15d
je 0x3a3d
leaq 0x56d3(%rip), %rdi      # 0x90a0
movl %r15d, %esi
xorl %eax, %eax
callq 0x3040
leaq 0x6(%rsp), %r9
movb $0x0, (%r9)
movl %ebx, %edi
movl $0x6a, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x3554
testl %eax, %eax
jne 0x39b4
imull $0x213, %r15d, %eax     # imm = 0x213
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
addb $-0x3c, %al
leaq 0x6(%rsp), %r9
movb %al, (%r9)
movl %ebx, %edi
movl $0x6a, %esi
movl $0xd8, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x3554
testl %eax, %eax
jne 0x39b4
testl %r14d, %r14d
je 0x3abd
leaq 0x566c(%rip), %rdi      # 0x90b5
movl %r14d, %esi
xorl %eax, %eax
callq 0x3040
leaq 0x6(%rsp), %r9
movb $0x1, (%r9)
movl %ebx, %edi
movl $0x6a, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x3554
testl %eax, %eax
jne 0x39b4
imull $0x213, %r14d, %eax     # imm = 0x213
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
addb $-0x3c, %al
leaq 0x6(%rsp), %r9
movb %al, (%r9)
movl %ebx, %edi
movl $0x6a, %esi
movl $0xd8, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x3554
testl %eax, %eax
jne 0x39b4
xorl %ebp, %ebp
jmp 0x39b4
leaq 0x6038(%rip), %rdi      # 0x9b03
callq 0x3310
movl $0x1, %edi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]brain-tools/include/json.hpp
// Function: void nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::dump_integer<long, 0>(long)
void dump_integer(NumberType x)
    {
        // special case for "0"
        if (x == 0)
        {
            o->write_character('0');
            return;
        }

        const bool is_negative = (x <= 0) and (x != 0);  // see issue #755
        std::size_t i = 0;

        while (x != 0)
        {
            // spare 1 byte for '\0'
            assert(i < number_buffer.size() - 1);

            const auto digit = std::labs(static_cast<long>(x % 10));
            number_buffer[i++] = static_cast<char>('0' + digit);
            x /= 10;
        }

        if (is_negative)
        {
            // make sure there is capacity for the '-'
            assert(i < number_buffer.size() - 2);
            number_buffer[i++] = '-';
        }

        std::reverse(number_buffer.begin(), number_buffer.begin() + i);
        o->write_characters(number_buffer.data(), i);
    }

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x5cf9
movq %rsi, %r8
leaq 0x10(%rdi), %rsi
xorl %ecx, %ecx
movabsq $0x6666666666666667, %r10 # imm = 0x6666666666666667
movq %r8, %r9
cmpq $0x3f, %rcx
je 0x5d0a
movq %r9, %rax
imulq %r10
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %r9, %r11
subq %rax, %r11
movq %r11, %rax
negq %rax
cmovsq %r11, %rax
addb $0x30, %al
movb %al, 0x10(%rdi,%rcx)
incq %rcx
addq $0x9, %r9
cmpq $0x12, %r9
movq %rdx, %r9
ja 0x5c58
testq %r8, %r8
jg 0x5cbb
leaq -0x1(%rcx), %rax
cmpq $0x3d, %rax
jae 0x5d29
movb $0x2d, 0x10(%rdi,%rcx)
incq %rcx
leaq (%rdi,%rcx), %rax
addq $0xf, %rax
cmpq %rsi, %rax
jbe 0x5ce9
leaq 0x11(%rdi), %rdx
movb -0x1(%rdx), %r8b
movb (%rax), %r9b
movb %r9b, -0x1(%rdx)
movb %r8b, (%rax)
decq %rax
leaq 0x1(%rdx), %r8
cmpq %rax, %rdx
movq %r8, %rdx
jb 0x5ccc
movq (%rdi), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %rcx, %rdx
popq %rcx
jmpq *%rax
movq (%rdi), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movl $0x30, %esi
popq %rcx
jmpq *%rax
leaq 0x3966(%rip), %rdi      # 0x9677
leaq 0x356a(%rip), %rsi      # 0x9282
leaq 0x3975(%rip), %rcx      # 0x9694
movl $0x19fd, %edx           # imm = 0x19FD
callq 0x3150
leaq 0x39f4(%rip), %rdi      # 0x9724
leaq 0x354b(%rip), %rsi      # 0x9282
leaq 0x3956(%rip), %rcx      # 0x9694
movl $0x1a07, %edx           # imm = 0x1A07
callq 0x3150
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/examples/BL2009/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "BL2009_dataset2.kms.rv";

    load(datafile, "kms", 0);

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
movq 0x2fd03(%rip), %rdx     # 0x50548
leaq 0x2fcf4(%rip), %r14     # 0x50540
leaq 0x2209a(%rip), %rcx     # 0x428ed
movl $0x16, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x8(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x1cc9b(%rip), %rsi     # 0x3d510
movq %r14, %rdi
callq 0x20a75
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x20b78
movq %r14, %rdi
movl $0x32, %esi
callq 0x20c4a
leaq 0x8(%rsp), %rdi
callq 0x20e28
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e28
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/gen-trialdivtab.c
// Function: sumspills
int
sumspills (mpz_t ppp, mpz_t *a, int n)
{
  mpz_t s;
  int i, ret;

  mpz_init_set (s, a[0]);

  for (i = 1; i < n; i++)
    {
      mpz_add (s, s, a[i]);
    }
  ret = mpz_cmp (s, B) >= 0;
  mpz_clear (s);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movq %rsi, %rbx
leaq -0x30(%rbp), %r15
movq $0x1, (%r15)
movl $0x8, %edi
callq *0x5e28(%rip)           # 0xf0a0
movq %rax, 0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2482
cmpl $0x2, %r14d
jl 0x92b2
movl %r14d, %r15d
addq $0x10, %rbx
decq %r15
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x30a3
addq $0x10, %rbx
decq %r15
jne 0x929b
leaq 0x5e27(%rip), %rsi      # 0xf0e0
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2cdb
movl %eax, %r14d
notl %r14d
shrl $0x1f, %r14d
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq *0x5dd5(%rip)           # 0xf0b0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Decomposition2D<double>::GetDetcoef(WaveledSubbdand, unsigned long) const
const Matrix<T>& Decomposition2D<T>::GetDetcoef(WaveledSubbdand subband, size_t n) const {
  if (subband != kHorizontalSubband && subband != kVerticalSubband && subband != kDiagonalSubband) {
    throw std::invalid_argument("Decomposition2D::GetDetcoef");
  }
  if (n >= NumLevels()) {
    throw std::invalid_argument("Decomposition2D::GetDetcoef ");
  }
  // Convert subband to int for indexing
  const size_t idx = static_cast<size_t>(subband);
  return this->at(3 * n + idx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %esi
jae 0x37df
movq %rdx, %r8
movq (%rdi), %r9
movq 0x8(%rdi), %rax
subq %r9, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
leaq -0x1(%rcx), %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq %rdx
cmpq %r8, %rdx
jbe 0x37fd
movl %esi, %eax
leaq (%r8,%r8,2), %rsi
addq %rax, %rsi
cmpq %rsi, %rcx
jbe 0x382f
leaq (%rsi,%rsi,4), %rax
leaq (%r9,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x59e5(%rip), %rsi      # 0x91d8
movq %rax, %rdi
callq 0x22f0
jmp 0x3819
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x59e3(%rip), %rsi      # 0x91f4
movq %rax, %rdi
callq 0x22f0
movq 0xa7c0(%rip), %rsi      # 0xdfe0
movq 0xa799(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
leaq 0x5a62(%rip), %rdi      # 0x9298
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x3842
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Decomposition2D<double>::SetDetcoef(Matrix<double> const&, WaveledSubbdand, unsigned long)
void Decomposition2D<T>::SetDetcoef(const Matrix<T>& d, WaveledSubbdand subband, size_t n) {
  if (subband != kHorizontalSubband && subband != kVerticalSubband && subband != kDiagonalSubband) {
    throw std::invalid_argument("Decomposition2D::SetDetcoef");
  }
  if (n >= NumLevels()) {
    throw std::invalid_argument("Decomposition2D::SetDetcoef ");
  }
  const size_t idx = static_cast<size_t>(subband);
  this->at(3 * n + idx) = d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %edx
jae 0x38c9
movl %edx, %r9d
movq (%rdi), %r10
movq 0x8(%rdi), %rax
subq %r10, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r8
leaq -0x1(%r8), %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq %rdx
cmpq %rcx, %rdx
jbe 0x38e7
movl %r9d, %edx
leaq (%rcx,%rcx,2), %rax
addq %rdx, %rax
cmpq %rax, %r8
jbe 0x3919
leaq (%rax,%rax,4), %rax
movups (%rsi), %xmm0
leaq (%r10,%rax,8), %rdi
addq $0x10, %rdi
movups %xmm0, -0x10(%rdi)
addq $0x10, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x354e
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x5934(%rip), %rsi      # 0x9211
movq %rax, %rdi
callq 0x22f0
jmp 0x3903
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x5932(%rip), %rsi      # 0x922d
movq %rax, %rdi
callq 0x22f0
movq 0xa6d6(%rip), %rsi      # 0xdfe0
movq 0xa6af(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
leaq 0x5978(%rip), %rdi      # 0x9298
movq %rax, %rsi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x392f
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Wavelet(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
Wavelet<T>::Wavelet(const std::vector<T>& Lo_D, const std::vector<T>& Hi_D,
                    const std::vector<T>& Lo_R, const std::vector<T>& Hi_R) {
  Lo_D_ = Lo_D;
  Hi_D_ = Hi_D;
  Lo_R_ = Lo_R;
  Hi_R_ = Hi_R;
  half_length_filter_ = Lo_D_.size() / 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, (%rsp)
leaq 0x30(%rdi), %r15
leaq 0x48(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
callq 0x354e
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x354e
movq %r15, %rdi
movq %rbp, %rsi
callq 0x354e
movq %r12, %rdi
movq %r13, %rsi
callq 0x354e
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
shrq %rax
movq %rax, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
testq %rdi, %rdi
je 0x39fb
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r15, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x2321
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Wavedec(std::vector<double, std::allocator<double>> const&, unsigned long) const
Decomposition1D<T> Wavelet<T>::Wavedec(const std::vector<T>& x, size_t num_levels) const {
  if (x.size() < (1 << num_levels)) {
    throw std::invalid_argument("Wavelet::Wavedec");
  }
  Decomposition1D<T> decomposition(num_levels);
  std::vector<T> a = x;
  for (size_t k = 0; k < num_levels; k++) {
    std::vector<T> ak, dk;
    Dwt(a, ak, dk);
    // Save approximation coefficients for next iteration
    a = ak;
    // Store detail coefficients of current level k to Decomposition object
    decomposition.SetDetcoef(dk, k);
  }
  // Store final approximation coefficients
  decomposition.SetAppcoef(a);
  return decomposition;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, 0x60(%rsp)
movq 0x8(%rdx), %rax
subq (%rdx), %rax
movl $0x1, %edx
shll %cl, %edx
sarq $0x3, %rax
movslq %edx, %rcx
cmpq %rcx, %rax
jb 0x3b95
movq %rdi, 0x8(%rsp)
movq %r14, %rsi
callq 0x3344
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x3034
testq %r14, %r14
je 0x3b55
xorl %r15d, %r15d
leaq 0x48(%rsp), %r12
leaq 0x30(%rsp), %r13
leaq 0x10(%rsp), %rbp
xorl %ebx, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq %r15, 0x40(%rsp)
movq %r15, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq 0x60(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x3c38
movq %r12, %rdi
movq %r13, %rsi
callq 0x354e
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x34cc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3b36
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3b4d
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
incq %rbx
cmpq %rbx, %r14
jne 0x3ada
movq 0x8(%rsp), %rbx
movq 0x8(%rbx), %rdi
addq $-0x18, %rdi
leaq 0x48(%rsp), %rsi
callq 0x354e
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x3b83
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x56a1(%rip), %rsi      # 0x924a
movq %rax, %rdi
callq 0x22f0
movq 0xa428(%rip), %rsi      # 0xdfe0
movq 0xa401(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
jmp 0x3c30
movq %rax, %r14
jmp 0x3c0f
movq %rax, %r14
jmp 0x3c26
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3bf8
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3c0f
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x3c26
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x8(%rsp), %rdi
callq 0x340c
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Appcoef(Decomposition1D<double> const&, unsigned long, unsigned long) const
std::vector<T> Wavelet<T>::Appcoef(const Decomposition1D<T>& decomposition, size_t level, size_t length_rec) const {
  std::vector<T> a = decomposition.GetAppcoef();
  for (size_t k = decomposition.NumLevels(); k != level; k--) {
    // Get size from next upper level, if current level is the final then
    // resort to the final lenght argument sz
    const size_t length_rec_k = k != 1 ? decomposition.GetDetcoef(k - 2).size() : length_rec;
    // Reconstruct signal of size s from kth level approx and detail
    a = Idwt(a, decomposition.GetDetcoef(k - 1), length_rec_k);
  }
  return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
addq $-0x18, %rsi
callq 0x3034
movq 0x8(%r12), %rax
subq (%r12), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rbp
leaq -0x1(%rbp), %rax
cmpq %r15, %rax
je 0x3e32
addq $-0x3, %rbp
negq %r15
movq 0x20(%rsp), %r14
cmpq $-0x1, %rbp
je 0x3db4
movq %r12, %rdi
movq %rbp, %rsi
callq 0x343a
movq 0x8(%rax), %r14
subq (%rax), %r14
sarq $0x3, %r14
leaq 0x1(%rbp), %rsi
movq %r12, %rdi
callq 0x343a
movq %rsp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %rax, %rcx
movq %r14, %r8
callq 0x3fe8
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x3e1e
subq %rdi, %rsi
callq 0x21d0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3e1e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
leaq (%r15,%rbp), %rax
decq %rax
decq %rbp
cmpq $-0x2, %rax
jne 0x3d93
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e46
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e5d
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Convdown(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&) const
std::vector<T> Wavelet<T>::Convdown(const std::vector<T>& x, const std::vector<T>& f) const {
  const size_t last = static_cast<size_t>(std::ceil(static_cast<double>(x.size()) / 2.0) * 2.0);
  std::vector<T> z = Wextend(x, half_length_filter_);
  z = Conv(z, f, kValidConvolution);
  std::vector<T> y(last / 2);
  for (size_t k = 1; k <= last; k += 2) {
    // Since k is always an odd integer, k/2 === floor(k/2)
    y[k / 2] = z[k];
  }
  return y;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x8(%rdx), %rax
subq (%rdx), %rax
sarq $0x3, %rax
movq %rax, %xmm1
punpckldq 0x52bc(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rdi, %rbx
subpd 0x52c1(%rip), %xmm1     # 0x9160
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x52dd(%rip), %xmm0     # 0x9190
callq 0x2060
movapd %xmm0, 0x40(%rsp)
movq 0x60(%r12), %rcx
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x5302
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x2, %ecx
callq 0x5455
movapd 0x40(%rsp), %xmm0
addsd %xmm0, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x5291(%rip), %xmm0     # 0x9198
cvttsd2si %xmm0, %r14
andq %rcx, %r14
orq %rax, %r14
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movapd 0x20(%rsp), %xmm0
movapd %xmm0, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
testq %rdi, %rdi
je 0x3f67
subq %rdi, %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3f67
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rsi
shrq %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x5628
movq (%rsp), %rdi
testq %r14, %r14
je 0x3fa1
movq (%rbx), %rax
movl $0x1, %ecx
movsd (%rdi,%rcx,8), %xmm0
movsd %xmm0, -0x4(%rax,%rcx,4)
addq $0x2, %rcx
cmpq %r14, %rcx
jbe 0x3f8b
jmp 0x3fa6
testq %rdi, %rdi
je 0x3fb3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3fc6
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3fdf
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Upconv(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, unsigned long) const
std::vector<T> Wavelet<T>::Upconv(const std::vector<T>& x, const std::vector<T>& f, size_t s) const {
  const size_t lf = f.size();
  std::vector<T> y = Dyadup(x);
  y = Wextend(y, lf / 2);
  y = Conv(y, f, kFullConvolution);
  y.erase(y.begin(), y.begin() + lf - 1);
  y.erase(y.begin() + s, y.end());
  return y;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rcx), %rbp
subq (%rcx), %rbp
movq %rbp, %r13
sarq $0x3, %r13
callq 0x56b6
shrq %r13
movq %rsp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x5302
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x41ef
subq %rdi, %rsi
callq 0x21d0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x41ef
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rsp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x5455
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x4249
subq %rdi, %rsi
callq 0x21d0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4249
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq (%rbx), %r15
movq 0x8(%rbx), %rdx
leaq (%r15,%rbp), %r12
addq $-0x8, %r12
cmpq %r12, %r15
je 0x428e
subq %r12, %rdx
je 0x4276
movq %r15, %rdi
movq %r12, %rsi
callq 0x2270
movq 0x8(%rbx), %rdx
movq %rdx, %rax
jmp 0x427c
movq %r12, %rdx
movq %r12, %rax
subq %r12, %rax
addq %rax, %r15
cmpq %r15, %rdx
je 0x428e
movq %r15, 0x8(%rbx)
movq %r15, %rdx
shlq $0x3, %r14
addq (%rbx), %r14
cmpq %rdx, %r14
je 0x429e
movq %r14, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42b2
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x42c9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Appcoef(Decomposition2D<double> const&, unsigned long, MatrixSize const&) const
Matrix<T> Wavelet<T>::Appcoef(const Decomposition2D<T>& decomposition, size_t level,
                              const MatrixSize& size_rec) const {
  Matrix<T> a = decomposition.GetAppcoef();
  for (size_t k = decomposition.NumLevels(); k != level; k--) {
    // Select size of reconstruction from any subband at the next highest level
    // We arbitrarily use the horizontal subband. If there is no next highest
    // level, then we use the size_rec argument.
    const MatrixSize s = (k != 1) ? decomposition.GetDetcoef(kHorizontalSubband, k - 2).Size() : size_rec;
    const Matrix<T>& hk = decomposition.GetDetcoef(kHorizontalSubband, k - 1);
    const Matrix<T>& vk = decomposition.GetDetcoef(kVerticalSubband, k - 1);
    const Matrix<T>& dk = decomposition.GetDetcoef(kDiagonalSubband, k - 1);
    a = Idwt(a, hk, vk, dk, s);
  }
  return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x28(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x38(%rsp)
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
movups -0x28(%rsi), %xmm0
movups %xmm0, (%rdi)
addq $0x10, %rdi
addq $-0x18, %rsi
movq %rdi, 0x30(%rsp)
callq 0x3034
movq 0x8(%r12), %rcx
subq (%r12), %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
decq %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r14
shrq %r14
cmpq %r15, %r14
je 0x46d0
movq %r15, %r13
decq %r14
negq %r13
testq %r14, %r14
je 0x4637
leaq -0x1(%r14), %rdx
movq %r12, %rdi
movl $0x2, %esi
callq 0x3780
movq %rax, %rdi
callq 0x639a
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
jmp 0x4644
movq 0x28(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r12, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x3780
movq %rax, %rbp
movq %r12, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x3780
movq %rax, %r15
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x3780
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
leaq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r15, %r8
movq %rax, %r9
callq 0x4a76
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x354e
leaq 0x40(%rsp), %rdi
callq 0x6376
leaq (%r14,%r13), %rax
decq %rax
decq %r14
cmpq $-0x1, %rax
jne 0x460d
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x46f9
jmp 0x46f9
jmp 0x46f9
jmp 0x46f9
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x6376
jmp 0x46fc
movq %rax, %r14
movq %rbx, %rdi
callq 0x6376
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Linrec(std::vector<double, std::allocator<double>> const&, unsigned long) const
std::vector<T> Wavelet<T>::Linrec(const std::vector<T>& a, size_t num_levels) const {
  Decomposition1D<T> c(num_levels);
  const size_t length = a.size();
  for (size_t k = 0; k < num_levels; k++) {
    // Set k-th level detail coefficients to zero
    std::vector<T> dk(length * (1 << (num_levels - k - 1)), static_cast<T>(0));
    c.SetDetcoef(dk, k);
  }
  // Set approx coefficients equal to the given input
  c.SetAppcoef(a);
  // Call Appcoef with length of reconstruction equal to N*2^n
  return Appcoef(c, 0, length * (1 << num_levels));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
movq %rcx, %rsi
callq 0x3344
movq 0x8(%r14), %r15
movq %r14, 0x20(%rsp)
subq (%r14), %r15
sarq $0x3, %r15
movq %rbx, 0x10(%rsp)
testq %rbx, %rbx
je 0x4f01
movq 0x10(%rsp), %rax
movq %rax, %r12
negq %r12
leal -0x1(%rax), %ebp
xorl %r14d, %r14d
leaq 0x50(%rsp), %rbx
leaq 0x38(%rsp), %r13
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
movslq %eax, %rsi
imulq %r15, %rsi
movq $0x0, 0x30(%rsp)
movq %rbx, %rdi
leaq 0x30(%rsp), %rdx
leaq 0xf(%rsp), %rcx
callq 0x4f92
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x34cc
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x4ef4
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
incq %r14
decl %ebp
movq %r12, %rax
addq %r14, %rax
jne 0x4ea4
movq 0x40(%rsp), %rdi
addq $-0x18, %rdi
movq 0x20(%rsp), %rsi
callq 0x354e
movq 0x28(%rsp), %rbx
movl $0x1, %eax
movq 0x10(%rsp), %rcx
shll %cl, %eax
cltq
imulq %rax, %r15
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
xorl %ecx, %ecx
movq %r15, %r8
callq 0x3d38
leaq 0x38(%rsp), %rdi
callq 0x340c
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f60
movq %rax, %rbx
jmp 0x4f7f
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x4f7f
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
leaq 0x38(%rsp), %rdi
callq 0x340c
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Linrec(Matrix<double> const&, unsigned long) const
Matrix<T> Wavelet<T>::Linrec(const Matrix<T>& a, size_t num_levels) const {
  Decomposition2D<T> c(num_levels);
  const size_t num_rows = a.GetNumRows();
  const size_t num_cols = a.GetNumColumns();
  for (size_t k = 0; k < num_levels; k++) {
    // Set all subbands at k-th level to zero
    Matrix<T> tmp(num_rows * (1 << (num_levels - k - 1)), num_cols * (1 << (num_levels - k - 1)), static_cast<T>(0));
    c.SetDetcoef(tmp, kDiagonalSubband, k);
    c.SetDetcoef(tmp, kVerticalSubband, k);
    c.SetDetcoef(tmp, kHorizontalSubband, k);
  }
  // Set approx coefficients equal to given input
  c.SetAppcoef(a);
  // Call Appcoef with size_rec equal to to M*2^n-by-N*2^n
  const MatrixSize size_rec(num_rows * (1 << num_levels), num_cols * (1 << num_levels));
  return Appcoef(c, 0, size_rec);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x3640
movq %r12, %rdi
callq 0x6390
movq %rax, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movq %r12, %rdi
callq 0x6394
movq %rax, %rbp
movq %r15, (%rsp)
testq %r15, %r15
je 0x519a
movq (%rsp), %rax
movq %rax, %r12
negq %r12
leal -0x1(%rax), %r14d
xorl %ebx, %ebx
leaq 0x40(%rsp), %r15
leaq 0x28(%rsp), %r13
movl $0x1, %eax
movl %r14d, %ecx
shll %cl, %eax
movslq %eax, %rdx
movq 0x8(%rsp), %rsi
imulq %rdx, %rsi
imulq %rbp, %rdx
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x6218
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x3856
movq %r13, %rdi
movq %r15, %rsi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3856
movq %r13, %rdi
movq %r15, %rsi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x3856
movq %r15, %rdi
callq 0x6376
incq %rbx
decl %r14d
movq %r12, %rax
addq %rbx, %rax
jne 0x5129
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movups (%rsi), %xmm0
movups %xmm0, -0x28(%rdi)
addq $-0x18, %rdi
addq $0x10, %rsi
callq 0x354e
movq (%rsp), %rcx
movl $0x1, %eax
shll %cl, %eax
cltq
movq 0x8(%rsp), %rcx
imulq %rax, %rcx
imulq %rax, %rbp
leaq 0x40(%rsp), %r8
movq %rcx, (%r8)
movq %rbp, 0x8(%r8)
leaq 0x28(%rsp), %rdx
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
xorl %ecx, %ecx
callq 0x458c
leaq 0x28(%rsp), %rdi
callq 0x3740
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5219
jmp 0x5219
jmp 0x5219
movq %rax, %rbx
jmp 0x522b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x6376
leaq 0x28(%rsp), %rdi
callq 0x3740
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Appcoef(Decomposition1D<double> const&, unsigned long) const
std::vector<T> Wavelet<T>::Appcoef(const Decomposition1D<T>& decomposition, size_t level) const {
  if (level >= decomposition.NumLevels()) {
    throw std::invalid_argument("Wavelet::Appcoef");
  }
  const size_t length_rec = (level == 0) ? 2 * decomposition.GetDetcoef(0).size() : decomposition.GetDetcoef(level - 1).size();
  return Appcoef(decomposition, level, length_rec);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq 0x8(%rdx), %rax
subq (%rdx), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
decq %rcx
cmpq %r14, %rcx
jbe 0x52bc
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
testq %r14, %r14
sete %bpl
xorl %esi, %esi
movq %r14, %rax
subq $0x1, %rax
cmovaeq %rax, %rsi
movq %rdx, %rdi
callq 0x343a
movq 0x8(%rax), %r8
subq (%rax), %r8
xorb $0x3, %bpl
movl %ebp, %ecx
sarq %cl, %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3d38
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x3f8b(%rip), %rsi      # 0x925b
movq %rax, %rdi
callq 0x22f0
movq 0x8d01(%rip), %rsi      # 0xdfe0
movq 0x8cda(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Wextend(std::vector<double, std::allocator<double>> const&, unsigned long) const
std::vector<T> Wavelet<T>::Wextend(const std::vector<T>& x, size_t lenEXT) const {
  std::vector<T> temp = x;
  // Add extra sample if signal is odd
  if (x.size() % 2 == 1) {
    temp.push_back(temp.back());
  }
  // Handle cases when x is shorter than lenEXT
  const size_t rep = lenEXT / temp.size(); // (size_t)std::floor(lenEXT/temp.size());
  const size_t len = lenEXT % temp.size();
  std::vector<T> y;
  y.reserve(2 * (len + rep * temp.size()) + temp.size());
  // Copy last len elements at the beginning
  y.insert(y.begin(), temp.end() - len, temp.end());
  for (size_t k = 0; k < 2 * rep + 1; k++) {
    y.insert(y.end(), temp.begin(), temp.end());
  }
  // Copy first len elements at the end
  y.insert(y.end(), temp.begin(), temp.begin() + len);
  return y;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x3034
movl 0x8(%r15), %eax
subl (%r15), %eax
testb $0x8, %al
je 0x5358
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x534c
movsd -0x8(%rsi), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x5358
leaq -0x8(%rsi), %rdx
movq %rsp, %rdi
callq 0x5e56
movq 0x8(%rsp), %rcx
subq (%rsp), %rcx
sarq $0x3, %rcx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r15
movq %rdx, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rcx, %rax
imulq %r15, %rax
addq %rdx, %rax
leaq (%rcx,%rax,2), %rsi
movq %rbx, %rdi
callq 0x58a4
movq (%rbx), %rsi
movq 0x8(%rsp), %rcx
leaq (,%r14,8), %rax
movq %rcx, %rdx
subq %rax, %rdx
movq %rbx, %rdi
callq 0x605a
addq %r15, %r15
movq $-0x1, %r12
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x605a
incq %r12
cmpq %r15, %r12
jb 0x53bf
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
leaq (%rdx,%r14,8), %rcx
movq %rbx, %rdi
callq 0x605a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5406
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x5437
jmp 0x5420
jmp 0x5420
jmp 0x5420
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5437
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x544d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Dyadup(std::vector<double, std::allocator<double>> const&) const
std::vector<T> Wavelet<T>::Dyadup(const std::vector<T>& x) const {
  // Return a vector having double length
  std::vector<T> y;
  y.reserve(2 * x.size());
  // The output vector interleaves the elements of x with zero
  for (size_t k = 0; k < x.size(); k++) {
    y.push_back(x[k]);
    y.push_back(0);
  }
  return y;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x2, %rsi
callq 0x58a4
movq (%r14), %rdx
cmpq %rdx, 0x8(%r14)
je 0x5775
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
addq %r12, %rdx
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0x5721
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5731
movq %rbx, %rdi
callq 0x5e56
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
movq $0x0, 0x8(%rsp)
cmpq %rax, %rsi
je 0x5750
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x575b
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5f7a
incq %r13
movq (%r14), %rdx
movq 0x8(%r14), %rax
subq %rdx, %rax
sarq $0x3, %rax
addq $0x8, %r12
cmpq %rax, %r13
jb 0x56ff
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x578a
jmp 0x578a
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x57a1
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/wavelet.cpp
// Function: Wavelet<double>::Appcoef(Decomposition2D<double> const&, unsigned long) const
Matrix<T> Wavelet<T>::Appcoef(const Decomposition2D<T>& decomposition, size_t level) const {
  if (level >= decomposition.NumLevels()) {
    throw std::invalid_argument("Wavelet::Appcoef2");
  }
  MatrixSize size_rec;
  if(level == 0) {
    // Level zero contains the biggest size of the decomposition, so we set the
    // reconstruction size equal to twice the size at level zero.
    const MatrixSize size_level_0 = decomposition.GetDetcoef(kHorizontalSubband, 0).Size();
    size_rec = MatrixSize(size_level_0.GetNumRows() * 2, size_level_0.GetNumColums() * 2);
  }
  else {
    // If level is not zero, get size of (any) subband at the next highest
    // level. We take here the horizontal subband.
    size_rec = decomposition.GetDetcoef(kHorizontalSubband, level - 1).Size();
  }
  return Appcoef(decomposition, level, size_rec);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
decq %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq %rdx
cmpq %r14, %rdx
jbe 0x585e
movq %rsi, %r15
movq %rdi, %r12
testq %r14, %r14
je 0x5812
leaq -0x1(%r14), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x3780
movq %rax, %rdi
callq 0x639a
jmp 0x5832
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x3780
movq %rax, %rdi
callq 0x639a
addq %rax, %rax
addq %rdx, %rdx
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
movq %rdx, 0x8(%r8)
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x458c
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x39fa(%rip), %rsi      # 0x926c
movq %rax, %rdi
callq 0x22f0
movq 0x875f(%rip), %rsi      # 0xdfe0
movq 0x8738(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::Matrix(unsigned long, unsigned long, std::vector<double, std::allocator<double>> const&)
Matrix<T>::Matrix(size_t num_rows, size_t num_cols, const std::vector<T>& data) {
  if (num_rows * num_cols != data.size()) {
    throw std::invalid_argument("Matrix::Matrix");
  }
  num_rows_ = num_rows;
  num_cols_ = num_cols;
  data_ = data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq %rdx, %rax
imulq %rsi, %rax
movq 0x8(%rcx), %rdi
subq (%rcx), %rdi
sarq $0x3, %rdi
cmpq %rdi, %rax
jne 0x6307
movq %rsi, (%rbx)
movq %rdx, 0x8(%rbx)
movq %r14, %rdi
movq %rcx, %rsi
callq 0x354e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %r12
leaq 0x3081(%rip), %rsi      # 0x939c
movq %rax, %rdi
callq 0x22f0
movq 0x7cb6(%rip), %rsi      # 0xdfe0
movq 0x7c8f(%rip), %rdx      # 0xdfc0
movq %r12, %rdi
callq 0x22b0
movq %rax, %r15
movq %r12, %rdi
callq 0x2140
jmp 0x6349
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x635d
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::Size() const
MatrixSize Matrix<T>::Size() const {
  if (num_rows_ * num_cols_ != data_.size()) {
    throw std::logic_error("Matrix::Size");
  }
  // clang++ suggests braces around initialization of subobject
  return MatrixSize(num_rows_, num_cols_);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq %rdx, %rcx
imulq %rax, %rcx
movq 0x18(%rdi), %rsi
subq 0x10(%rdi), %rsi
sarq $0x3, %rsi
cmpq %rsi, %rcx
jne 0x63c5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x2fd2(%rip), %rsi      # 0x93ab
movq %rax, %rdi
callq 0x2210
movq 0x7bf0(%rip), %rsi      # 0xdfd8
movq 0x7bb9(%rip), %rdx      # 0xdfa8
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22d0